]> 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
Removed obsolete code
[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_wxEventLoop swig_types[38]
2505 #define SWIGTYPE_p_wxEventLoopActivator swig_types[39]
2506 #define SWIGTYPE_p_wxEvtHandler swig_types[40]
2507 #define SWIGTYPE_p_wxFSFile swig_types[41]
2508 #define SWIGTYPE_p_wxFileSystem swig_types[42]
2509 #define SWIGTYPE_p_wxFileSystemHandler swig_types[43]
2510 #define SWIGTYPE_p_wxFlexGridSizer swig_types[44]
2511 #define SWIGTYPE_p_wxFocusEvent swig_types[45]
2512 #define SWIGTYPE_p_wxFont swig_types[46]
2513 #define SWIGTYPE_p_wxFrame swig_types[47]
2514 #define SWIGTYPE_p_wxGBPosition swig_types[48]
2515 #define SWIGTYPE_p_wxGBSizerItem swig_types[49]
2516 #define SWIGTYPE_p_wxGBSpan swig_types[50]
2517 #define SWIGTYPE_p_wxGIFHandler swig_types[51]
2518 #define SWIGTYPE_p_wxGridBagSizer swig_types[52]
2519 #define SWIGTYPE_p_wxGridSizer swig_types[53]
2520 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[54]
2521 #define SWIGTYPE_p_wxICOHandler swig_types[55]
2522 #define SWIGTYPE_p_wxIconizeEvent swig_types[56]
2523 #define SWIGTYPE_p_wxIdleEvent swig_types[57]
2524 #define SWIGTYPE_p_wxImage swig_types[58]
2525 #define SWIGTYPE_p_wxImageHandler swig_types[59]
2526 #define SWIGTYPE_p_wxImageHistogram swig_types[60]
2527 #define SWIGTYPE_p_wxImage_HSVValue swig_types[61]
2528 #define SWIGTYPE_p_wxImage_RGBValue swig_types[62]
2529 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[63]
2530 #define SWIGTYPE_p_wxInitDialogEvent swig_types[64]
2531 #define SWIGTYPE_p_wxInputStream swig_types[65]
2532 #define SWIGTYPE_p_wxInternetFSHandler swig_types[66]
2533 #define SWIGTYPE_p_wxItemContainer swig_types[67]
2534 #define SWIGTYPE_p_wxJPEGHandler swig_types[68]
2535 #define SWIGTYPE_p_wxKeyEvent swig_types[69]
2536 #define SWIGTYPE_p_wxLayoutConstraints swig_types[70]
2537 #define SWIGTYPE_p_wxMaximizeEvent swig_types[71]
2538 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[72]
2539 #define SWIGTYPE_p_wxMenu swig_types[73]
2540 #define SWIGTYPE_p_wxMenuBar swig_types[74]
2541 #define SWIGTYPE_p_wxMenuBarBase swig_types[75]
2542 #define SWIGTYPE_p_wxMenuEvent swig_types[76]
2543 #define SWIGTYPE_p_wxMenuItem swig_types[77]
2544 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMouseEvent swig_types[80]
2547 #define SWIGTYPE_p_wxMoveEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNcPaintEvent swig_types[83]
2550 #define SWIGTYPE_p_wxNotifyEvent swig_types[84]
2551 #define SWIGTYPE_p_wxObject swig_types[85]
2552 #define SWIGTYPE_p_wxOutputStream swig_types[86]
2553 #define SWIGTYPE_p_wxPCXHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPNGHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPNMHandler swig_types[89]
2556 #define SWIGTYPE_p_wxPaintEvent swig_types[90]
2557 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[91]
2558 #define SWIGTYPE_p_wxPaperSize swig_types[92]
2559 #define SWIGTYPE_p_wxPoint swig_types[93]
2560 #define SWIGTYPE_p_wxPoint2D swig_types[94]
2561 #define SWIGTYPE_p_wxPropagateOnce swig_types[95]
2562 #define SWIGTYPE_p_wxPropagationDisabler swig_types[96]
2563 #define SWIGTYPE_p_wxPyApp swig_types[97]
2564 #define SWIGTYPE_p_wxPyCommandEvent swig_types[98]
2565 #define SWIGTYPE_p_wxPyDropTarget swig_types[99]
2566 #define SWIGTYPE_p_wxPyEvent swig_types[100]
2567 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[101]
2568 #define SWIGTYPE_p_wxPyImageHandler swig_types[102]
2569 #define SWIGTYPE_p_wxPyInputStream swig_types[103]
2570 #define SWIGTYPE_p_wxPySizer swig_types[104]
2571 #define SWIGTYPE_p_wxPyValidator swig_types[105]
2572 #define SWIGTYPE_p_wxQuantize swig_types[106]
2573 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[107]
2574 #define SWIGTYPE_p_wxRealPoint swig_types[108]
2575 #define SWIGTYPE_p_wxRect swig_types[109]
2576 #define SWIGTYPE_p_wxRect2D swig_types[110]
2577 #define SWIGTYPE_p_wxRegion swig_types[111]
2578 #define SWIGTYPE_p_wxScrollEvent swig_types[112]
2579 #define SWIGTYPE_p_wxScrollWinEvent swig_types[113]
2580 #define SWIGTYPE_p_wxSetCursorEvent swig_types[114]
2581 #define SWIGTYPE_p_wxShowEvent swig_types[115]
2582 #define SWIGTYPE_p_wxSize swig_types[116]
2583 #define SWIGTYPE_p_wxSizeEvent swig_types[117]
2584 #define SWIGTYPE_p_wxSizer swig_types[118]
2585 #define SWIGTYPE_p_wxSizerItem swig_types[119]
2586 #define SWIGTYPE_p_wxStaticBox swig_types[120]
2587 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[121]
2588 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[122]
2589 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[123]
2590 #define SWIGTYPE_p_wxTGAHandler swig_types[124]
2591 #define SWIGTYPE_p_wxTIFFHandler swig_types[125]
2592 #define SWIGTYPE_p_wxToolTip swig_types[126]
2593 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[127]
2594 #define SWIGTYPE_p_wxValidator swig_types[128]
2595 #define SWIGTYPE_p_wxVisualAttributes swig_types[129]
2596 #define SWIGTYPE_p_wxWindow swig_types[130]
2597 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[131]
2598 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[132]
2599 #define SWIGTYPE_p_wxXPMHandler swig_types[133]
2600 #define SWIGTYPE_p_wxZipFSHandler swig_types[134]
2601 static swig_type_info *swig_types[136];
2602 static swig_module_info swig_module = {swig_types, 135, 0, 0, 0, 0};
2603 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2604 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2605
2606 /* -------- TYPES TABLE (END) -------- */
2607
2608 #if (PY_VERSION_HEX <= 0x02000000)
2609 # if !defined(SWIG_PYTHON_CLASSIC)
2610 # error "This python version requires to use swig with the '-classic' option"
2611 # endif
2612 #endif
2613 #if (PY_VERSION_HEX <= 0x02020000)
2614 # error "This python version requires to use swig with the '-nomodern' option"
2615 #endif
2616 #if (PY_VERSION_HEX <= 0x02020000)
2617 # error "This python version requires to use swig with the '-nomodernargs' option"
2618 #endif
2619 #ifndef METH_O
2620 # error "This python version requires to use swig with the '-nofastunpack' option"
2621 #endif
2622
2623 /*-----------------------------------------------
2624 @(target):= _core_.so
2625 ------------------------------------------------*/
2626 #define SWIG_init init_core_
2627
2628 #define SWIG_name "_core_"
2629
2630 #define SWIGVERSION 0x010329
2631
2632
2633 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2634 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2635
2636
2637 #include <stdexcept>
2638
2639
2640 namespace swig {
2641 class PyObject_ptr {
2642 protected:
2643 PyObject *_obj;
2644
2645 public:
2646 PyObject_ptr() :_obj(0)
2647 {
2648 }
2649
2650 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2651 {
2652 Py_XINCREF(_obj);
2653 }
2654
2655 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2656 {
2657 if (initial_ref) Py_XINCREF(_obj);
2658 }
2659
2660 PyObject_ptr & operator=(const PyObject_ptr& item)
2661 {
2662 Py_XINCREF(item._obj);
2663 Py_XDECREF(_obj);
2664 _obj = item._obj;
2665 return *this;
2666 }
2667
2668 ~PyObject_ptr()
2669 {
2670 Py_XDECREF(_obj);
2671 }
2672
2673 operator PyObject *() const
2674 {
2675 return _obj;
2676 }
2677
2678 PyObject *operator->() const
2679 {
2680 return _obj;
2681 }
2682 };
2683 }
2684
2685
2686 namespace swig {
2687 struct PyObject_var : PyObject_ptr {
2688 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2689
2690 PyObject_var & operator = (PyObject* obj)
2691 {
2692 Py_XDECREF(_obj);
2693 _obj = obj;
2694 return *this;
2695 }
2696 };
2697 }
2698
2699
2700 #include "wx/wxPython/wxPython_int.h"
2701 #include "wx/wxPython/pyclasses.h"
2702 #include "wx/wxPython/twoitem.h"
2703
2704
2705 #ifndef wxPyUSE_EXPORT
2706 // Helper functions for dealing with SWIG objects and such. These are
2707 // located here so they know about the SWIG types and functions declared
2708 // in the wrapper code.
2709
2710 #include <wx/hashmap.h>
2711 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2712
2713
2714 // Maintains a hashmap of className to swig_type_info pointers. Given the
2715 // name of a class either looks up the type info in the cache, or scans the
2716 // SWIG tables for it.
2717 extern PyObject* wxPyPtrTypeMap;
2718 static
2719 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2720
2721 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2722
2723 if (typeInfoCache == NULL)
2724 typeInfoCache = new wxPyTypeInfoHashMap;
2725
2726 wxString name(className);
2727 swig_type_info* swigType = (*typeInfoCache)[name];
2728
2729 if (! swigType) {
2730 // it wasn't in the cache, so look it up from SWIG
2731 name.Append(wxT(" *"));
2732 swigType = SWIG_TypeQuery(name.mb_str());
2733
2734 // if it still wasn't found, try looking for a mapped name
2735 if (!swigType) {
2736 PyObject* item;
2737 name = className;
2738
2739 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2740 (char*)(const char*)name.mbc_str())) != NULL) {
2741 name = wxString(PyString_AsString(item), *wxConvCurrent);
2742 name.Append(wxT(" *"));
2743 swigType = SWIG_TypeQuery(name.mb_str());
2744 }
2745 }
2746 if (swigType) {
2747 // and add it to the map if found
2748 (*typeInfoCache)[className] = swigType;
2749 }
2750 }
2751 return swigType;
2752 }
2753
2754
2755 // Check if a class name is a type known to SWIG
2756 bool wxPyCheckSwigType(const wxChar* className) {
2757
2758 swig_type_info* swigType = wxPyFindSwigType(className);
2759 return swigType != NULL;
2760 }
2761
2762
2763 // Given a pointer to a C++ object and a class name, construct a Python proxy
2764 // object for it.
2765 PyObject* wxPyConstructObject(void* ptr,
2766 const wxChar* className,
2767 int setThisOwn) {
2768
2769 swig_type_info* swigType = wxPyFindSwigType(className);
2770 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2771
2772 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2773 }
2774
2775
2776 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2777 // Ensures that the proxy object is of the specified (or derived) type. If
2778 // not able to perform the conversion then a Python exception is set and the
2779 // error should be handled properly in the caller. Returns True on success.
2780 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2781 const wxChar* className) {
2782
2783 swig_type_info* swigType = wxPyFindSwigType(className);
2784 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2785
2786 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2787 }
2788
2789
2790
2791 // Make a SWIGified pointer object suitable for a .this attribute
2792 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2793
2794 PyObject* robj = NULL;
2795
2796 swig_type_info* swigType = wxPyFindSwigType(className);
2797 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2798
2799 robj = PySwigObject_New(ptr, swigType, 0);
2800 return robj;
2801 }
2802
2803
2804 // Python's PyInstance_Check does not return True for instances of new-style
2805 // classes. This should get close enough for both new and old classes but I
2806 // should re-evaluate the need for doing instance checks...
2807 bool wxPyInstance_Check(PyObject* obj) {
2808 return PyObject_HasAttrString(obj, "__class__") != 0;
2809 }
2810
2811
2812 // This one checks if the object is an instance of a SWIG proxy class (it has
2813 // a .this attribute, and the .this attribute is a PySwigObject.)
2814 bool wxPySwigInstance_Check(PyObject* obj) {
2815 static PyObject* this_str = NULL;
2816 if (this_str == NULL)
2817 this_str = PyString_FromString("this");
2818
2819 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2820 if (this_attr) {
2821 bool retval = (PySwigObject_Check(this_attr) != 0);
2822 Py_DECREF(this_attr);
2823 return retval;
2824 }
2825
2826 PyErr_Clear();
2827 return false;
2828 }
2829
2830
2831 // Export a C API in a struct. Other modules will be able to load this from
2832 // the wx._core_ module and will then have safe access to these functions,
2833 // even if they are located in another shared library.
2834 static wxPyCoreAPI API = {
2835
2836 wxPyCheckSwigType,
2837 wxPyConstructObject,
2838 wxPyConvertSwigPtr,
2839 wxPyMakeSwigPtr,
2840
2841 wxPyBeginAllowThreads,
2842 wxPyEndAllowThreads,
2843 wxPyBeginBlockThreads,
2844 wxPyEndBlockThreads,
2845
2846 wxPy_ConvertList,
2847
2848 wxString_in_helper,
2849 Py2wxString,
2850 wx2PyString,
2851
2852 byte_LIST_helper,
2853 int_LIST_helper,
2854 long_LIST_helper,
2855 string_LIST_helper,
2856 wxPoint_LIST_helper,
2857 wxBitmap_LIST_helper,
2858 wxString_LIST_helper,
2859 wxAcceleratorEntry_LIST_helper,
2860
2861 wxSize_helper,
2862 wxPoint_helper,
2863 wxRealPoint_helper,
2864 wxRect_helper,
2865 wxColour_helper,
2866 wxPoint2D_helper,
2867
2868 wxPySimple_typecheck,
2869 wxColour_typecheck,
2870
2871 wxPyCBH_setCallbackInfo,
2872 wxPyCBH_findCallback,
2873 wxPyCBH_callCallback,
2874 wxPyCBH_callCallbackObj,
2875 wxPyCBH_delete,
2876
2877 wxPyMake_wxObject,
2878 wxPyMake_wxSizer,
2879 wxPyPtrTypeMap_Add,
2880 wxPy2int_seq_helper,
2881 wxPy4int_seq_helper,
2882 wxArrayString2PyList_helper,
2883 wxArrayInt2PyList_helper,
2884
2885 wxPyClientData_dtor,
2886 wxPyUserData_dtor,
2887 wxPyOORClientData_dtor,
2888
2889 wxPyCBInputStream_create,
2890 wxPyCBInputStream_copy,
2891
2892 wxPyInstance_Check,
2893 wxPySwigInstance_Check,
2894
2895 wxPyCheckForApp,
2896
2897 wxArrayDouble2PyList_helper,
2898 wxPoint2D_LIST_helper,
2899 wxRect2D_helper,
2900
2901 };
2902
2903 #endif
2904
2905
2906 #if !WXWIN_COMPATIBILITY_2_4
2907 #define wxHIDE_READONLY 0
2908 #endif
2909
2910
2911 #define SWIG_From_long PyInt_FromLong
2912
2913
2914 SWIGINTERNINLINE PyObject *
2915 SWIG_From_int (int value)
2916 {
2917 return SWIG_From_long (value);
2918 }
2919
2920 static const wxString wxPyEmptyString(wxEmptyString);
2921 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2922 return self->GetClassInfo()->GetClassName();
2923 }
2924 SWIGINTERN void wxObject_Destroy(wxObject *self){
2925 delete self;
2926 }
2927
2928 #ifndef __WXMAC__
2929 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2930 #endif
2931
2932
2933 #include <limits.h>
2934 #ifndef LLONG_MIN
2935 # define LLONG_MIN LONG_LONG_MIN
2936 #endif
2937 #ifndef LLONG_MAX
2938 # define LLONG_MAX LONG_LONG_MAX
2939 #endif
2940 #ifndef ULLONG_MAX
2941 # define ULLONG_MAX ULONG_LONG_MAX
2942 #endif
2943
2944
2945 SWIGINTERN int
2946 SWIG_AsVal_long (PyObject* obj, long* val)
2947 {
2948 if (PyNumber_Check(obj)) {
2949 if (val) *val = PyInt_AsLong(obj);
2950 return SWIG_OK;
2951 }
2952 return SWIG_TypeError;
2953 }
2954
2955
2956 SWIGINTERN int
2957 SWIG_AsVal_int (PyObject * obj, int *val)
2958 {
2959 long v;
2960 int res = SWIG_AsVal_long (obj, &v);
2961 if (SWIG_IsOK(res)) {
2962 if ((v < INT_MIN || v > INT_MAX)) {
2963 return SWIG_OverflowError;
2964 } else {
2965 if (val) *val = static_cast< int >(v);
2966 }
2967 }
2968 return res;
2969 }
2970
2971 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2972 wxSize temp, *obj = &temp;
2973 if ( other == Py_None ) return false;
2974 if ( ! wxSize_helper(other, &obj) ) {
2975 PyErr_Clear();
2976 return false;
2977 }
2978 return self->operator==(*obj);
2979 }
2980 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2981 wxSize temp, *obj = &temp;
2982 if ( other == Py_None ) return true;
2983 if ( ! wxSize_helper(other, &obj)) {
2984 PyErr_Clear();
2985 return true;
2986 }
2987 return self->operator!=(*obj);
2988 }
2989
2990 #include <float.h>
2991
2992
2993 SWIGINTERN int
2994 SWIG_AsVal_double (PyObject *obj, double* val)
2995 {
2996 if (PyNumber_Check(obj)) {
2997 if (val) *val = PyFloat_AsDouble(obj);
2998 return SWIG_OK;
2999 }
3000 return SWIG_TypeError;
3001 }
3002
3003
3004 SWIGINTERN int
3005 SWIG_AsVal_float (PyObject * obj, float *val)
3006 {
3007 double v;
3008 int res = SWIG_AsVal_double (obj, &v);
3009 if (SWIG_IsOK(res)) {
3010 if ((v < -FLT_MAX || v > FLT_MAX)) {
3011 return SWIG_OverflowError;
3012 } else {
3013 if (val) *val = static_cast< float >(v);
3014 }
3015 }
3016 return res;
3017 }
3018
3019 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3020 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3021 PyObject* tup = PyTuple_New(2);
3022 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3023 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3024 //wxPyEndBlockThreads(blocked);
3025 return tup;
3026 }
3027
3028 #define SWIG_From_double PyFloat_FromDouble
3029
3030 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3031 wxRealPoint temp, *obj = &temp;
3032 if ( other == Py_None ) return false;
3033 if ( ! wxRealPoint_helper(other, &obj) ) {
3034 PyErr_Clear();
3035 return false;
3036 }
3037 return self->operator==(*obj);
3038 }
3039 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3040 wxRealPoint temp, *obj = &temp;
3041 if ( other == Py_None ) return true;
3042 if ( ! wxRealPoint_helper(other, &obj)) {
3043 PyErr_Clear();
3044 return true;
3045 }
3046 return self->operator!=(*obj);
3047 }
3048 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3049 self->x = x;
3050 self->y = y;
3051 }
3052 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3053 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3054 PyObject* tup = PyTuple_New(2);
3055 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3056 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3057 //PyEndBlockThreads(blocked);
3058 return tup;
3059 }
3060 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3061 wxPoint temp, *obj = &temp;
3062 if ( other == Py_None ) return false;
3063 if ( ! wxPoint_helper(other, &obj) ) {
3064 PyErr_Clear();
3065 return false;
3066 }
3067 return self->operator==(*obj);
3068 }
3069 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3070 wxPoint temp, *obj = &temp;
3071 if ( other == Py_None ) return true;
3072 if ( ! wxPoint_helper(other, &obj)) {
3073 PyErr_Clear();
3074 return true;
3075 }
3076 return self->operator!=(*obj);
3077 }
3078 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3079 self->x = x;
3080 self->y = y;
3081 }
3082 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3083 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3084 PyObject* tup = PyTuple_New(2);
3085 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3086 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3087 //wxPyEndBlockThreads(blocked);
3088 return tup;
3089 }
3090 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3091 wxRect temp, *obj = &temp;
3092 if ( other == Py_None ) return false;
3093 if ( ! wxRect_helper(other, &obj) ) {
3094 PyErr_Clear();
3095 return false;
3096 }
3097 return self->operator==(*obj);
3098 }
3099 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3100 wxRect temp, *obj = &temp;
3101 if ( other == Py_None ) return true;
3102 if ( ! wxRect_helper(other, &obj)) {
3103 PyErr_Clear();
3104 return true;
3105 }
3106 return self->operator!=(*obj);
3107 }
3108 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3109 self->x = x;
3110 self->y = y;
3111 self->width = width;
3112 self->height = height;
3113 }
3114 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3115 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3116 PyObject* tup = PyTuple_New(4);
3117 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3118 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3119 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3120 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3121 //wxPyEndBlockThreads(blocked);
3122 return tup;
3123 }
3124
3125 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3126 wxRegion reg1(*r1);
3127 wxRegion reg2(*r2);
3128 wxRect dest(0,0,0,0);
3129 PyObject* obj;
3130
3131 reg1.Intersect(reg2);
3132 dest = reg1.GetBox();
3133
3134 if (dest != wxRect(0,0,0,0)) {
3135 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3136 wxRect* newRect = new wxRect(dest);
3137 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3138 //wxPyEndBlockThreads(blocked);
3139 return obj;
3140 }
3141 Py_INCREF(Py_None);
3142 return Py_None;
3143 }
3144
3145 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3146 wxPoint2D temp, *obj = &temp;
3147 if ( other == Py_None ) return false;
3148 if ( ! wxPoint2D_helper(other, &obj) ) {
3149 PyErr_Clear();
3150 return false;
3151 }
3152 return self->operator==(*obj);
3153 }
3154 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3155 wxPoint2D temp, *obj = &temp;
3156 if ( other == Py_None ) return true;
3157 if ( ! wxPoint2D_helper(other, &obj)) {
3158 PyErr_Clear();
3159 return true;
3160 }
3161 return self->operator!=(*obj);
3162 }
3163 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3164 self->m_x = x;
3165 self->m_y = y;
3166 }
3167 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3168 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3169 PyObject* tup = PyTuple_New(2);
3170 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3171 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3172 //wxPyEndBlockThreads(blocked);
3173 return tup;
3174 }
3175 SWIGINTERN bool wxRect2D___eq__(wxRect2D *self,PyObject *other){
3176 wxRect2D temp, *obj = &temp;
3177 if ( other == Py_None ) return false;
3178 if ( ! wxRect2D_helper(other, &obj) ) {
3179 PyErr_Clear();
3180 return false;
3181 }
3182 return self->operator==(*obj);
3183 }
3184 SWIGINTERN bool wxRect2D___ne__(wxRect2D *self,PyObject *other){
3185 wxRect2D temp, *obj = &temp;
3186 if ( other == Py_None ) return true;
3187 if ( ! wxRect2D_helper(other, &obj)) {
3188 PyErr_Clear();
3189 return true;
3190 }
3191 return self->operator!=(*obj);
3192 }
3193 SWIGINTERN void wxRect2D_Set(wxRect2D *self,wxDouble x=0,wxDouble y=0,wxDouble width=0,wxDouble height=0){
3194 self->m_x = x;
3195 self->m_y = y;
3196 self->m_width = width;
3197 self->m_height = height;
3198 }
3199 SWIGINTERN PyObject *wxRect2D_Get(wxRect2D *self){
3200 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3201 PyObject* tup = PyTuple_New(4);
3202 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3203 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3204 PyTuple_SET_ITEM(tup, 2, PyFloat_FromDouble(self->m_width));
3205 PyTuple_SET_ITEM(tup, 3, PyFloat_FromDouble(self->m_height));
3206 //wxPyEndBlockThreads(blocked);
3207 return tup;
3208 }
3209
3210 #include "wx/wxPython/pyistream.h"
3211
3212 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3213 wxInputStream* wxis = wxPyCBInputStream::create(p);
3214 if (wxis)
3215 return new wxPyInputStream(wxis);
3216 else
3217 return NULL;
3218 }
3219
3220 SWIGINTERN swig_type_info*
3221 SWIG_pchar_descriptor()
3222 {
3223 static int init = 0;
3224 static swig_type_info* info = 0;
3225 if (!init) {
3226 info = SWIG_TypeQuery("_p_char");
3227 init = 1;
3228 }
3229 return info;
3230 }
3231
3232
3233 SWIGINTERNINLINE PyObject *
3234 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3235 {
3236 if (carray) {
3237 if (size > INT_MAX) {
3238 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3239 return pchar_descriptor ?
3240 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3241 } else {
3242 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3243 }
3244 } else {
3245 return SWIG_Py_Void();
3246 }
3247 }
3248
3249
3250 SWIGINTERNINLINE PyObject *
3251 SWIG_From_char (char c)
3252 {
3253 return SWIG_FromCharPtrAndSize(&c,1);
3254 }
3255
3256
3257 SWIGINTERNINLINE PyObject*
3258 SWIG_From_unsigned_SS_long (unsigned long value)
3259 {
3260 return (value > LONG_MAX) ?
3261 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3262 }
3263
3264
3265 SWIGINTERNINLINE PyObject *
3266 SWIG_From_size_t (size_t value)
3267 {
3268 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3269 }
3270
3271
3272 SWIGINTERN int
3273 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3274 {
3275 if (PyString_Check(obj)) {
3276 char *cstr; Py_ssize_t len;
3277 PyString_AsStringAndSize(obj, &cstr, &len);
3278 if (cptr) {
3279 if (alloc) {
3280 /*
3281 In python the user should not be able to modify the inner
3282 string representation. To warranty that, if you define
3283 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3284 buffer is always returned.
3285
3286 The default behavior is just to return the pointer value,
3287 so, be careful.
3288 */
3289 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3290 if (*alloc != SWIG_OLDOBJ)
3291 #else
3292 if (*alloc == SWIG_NEWOBJ)
3293 #endif
3294 {
3295 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3296 *alloc = SWIG_NEWOBJ;
3297 }
3298 else {
3299 *cptr = cstr;
3300 *alloc = SWIG_OLDOBJ;
3301 }
3302 } else {
3303 *cptr = PyString_AsString(obj);
3304 }
3305 }
3306 if (psize) *psize = len + 1;
3307 return SWIG_OK;
3308 } else {
3309 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3310 if (pchar_descriptor) {
3311 void* vptr = 0;
3312 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3313 if (cptr) *cptr = (char *) vptr;
3314 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3315 if (alloc) *alloc = SWIG_OLDOBJ;
3316 return SWIG_OK;
3317 }
3318 }
3319 }
3320 return SWIG_TypeError;
3321 }
3322
3323
3324 SWIGINTERN int
3325 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3326 {
3327 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3328 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3329 if (SWIG_IsOK(res)) {
3330 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3331 if (csize <= size) {
3332 if (val) {
3333 if (csize) memcpy(val, cptr, csize*sizeof(char));
3334 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3335 }
3336 if (alloc == SWIG_NEWOBJ) {
3337 delete[] cptr;
3338 res = SWIG_DelNewMask(res);
3339 }
3340 return res;
3341 }
3342 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3343 }
3344 return SWIG_TypeError;
3345 }
3346
3347
3348 SWIGINTERN int
3349 SWIG_AsVal_char (PyObject * obj, char *val)
3350 {
3351 int res = SWIG_AsCharArray(obj, val, 1);
3352 if (!SWIG_IsOK(res)) {
3353 long v;
3354 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3355 if (SWIG_IsOK(res)) {
3356 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3357 if (val) *val = static_cast< char >(v);
3358 } else {
3359 res = SWIG_OverflowError;
3360 }
3361 }
3362 }
3363 return res;
3364 }
3365
3366 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3367 // We use only strings for the streams, not unicode
3368 PyObject* str = PyObject_Str(obj);
3369 if (! str) {
3370 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3371 return;
3372 }
3373 self->Write(PyString_AS_STRING(str),
3374 PyString_GET_SIZE(str));
3375 Py_DECREF(str);
3376 }
3377
3378 #include "wx/wxPython/pyistream.h"
3379
3380
3381 class wxPyFileSystemHandler : public wxFileSystemHandler
3382 {
3383 public:
3384 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3385
3386 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3387 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3388 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3389 DEC_PYCALLBACK_STRING__pure(FindNext);
3390
3391 wxString GetProtocol(const wxString& location) {
3392 return wxFileSystemHandler::GetProtocol(location);
3393 }
3394
3395 wxString GetLeftLocation(const wxString& location) {
3396 return wxFileSystemHandler::GetLeftLocation(location);
3397 }
3398
3399 wxString GetAnchor(const wxString& location) {
3400 return wxFileSystemHandler::GetAnchor(location);
3401 }
3402
3403 wxString GetRightLocation(const wxString& location) {
3404 return wxFileSystemHandler::GetRightLocation(location);
3405 }
3406
3407 wxString GetMimeTypeFromExt(const wxString& location) {
3408 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3409 }
3410
3411 PYPRIVATE;
3412 };
3413
3414
3415 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3416 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3417 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3418 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3419
3420
3421 SWIGINTERN int
3422 SWIG_AsVal_bool (PyObject *obj, bool *val)
3423 {
3424 if (obj == Py_True) {
3425 if (val) *val = true;
3426 return SWIG_OK;
3427 } else if (obj == Py_False) {
3428 if (val) *val = false;
3429 return SWIG_OK;
3430 } else {
3431 long v = 0;
3432 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3433 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3434 return res;
3435 }
3436 }
3437
3438 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3439 wxFileName fname = wxFileSystem::URLToFileName(url);
3440 return fname.GetFullPath();
3441 }
3442
3443 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3444 wxImage& image,
3445 long type) {
3446 wxMemoryFSHandler::AddFile(filename, image, type);
3447 }
3448
3449 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3450 const wxBitmap& bitmap,
3451 long type) {
3452 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3453 }
3454
3455 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3456 PyObject* data) {
3457 if (! PyString_Check(data)) {
3458 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3459 "Expected string object"));
3460 return;
3461 }
3462
3463 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3464 void* ptr = (void*)PyString_AsString(data);
3465 size_t size = PyString_Size(data);
3466 wxPyEndBlockThreads(blocked);
3467
3468 wxMemoryFSHandler::AddFile(filename, ptr, size);
3469 }
3470
3471
3472 #include "wx/wxPython/pyistream.h"
3473
3474
3475 SWIGINTERN int
3476 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3477 {
3478 long v = 0;
3479 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3480 return SWIG_TypeError;
3481 }
3482 else if (val)
3483 *val = (unsigned long)v;
3484 return SWIG_OK;
3485 }
3486
3487
3488 SWIGINTERN int
3489 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3490 {
3491 unsigned long v;
3492 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3493 if (SWIG_IsOK(res)) {
3494 if ((v > UCHAR_MAX)) {
3495 return SWIG_OverflowError;
3496 } else {
3497 if (val) *val = static_cast< unsigned char >(v);
3498 }
3499 }
3500 return res;
3501 }
3502
3503
3504 SWIGINTERNINLINE PyObject *
3505 SWIG_From_unsigned_SS_char (unsigned char value)
3506 {
3507 return SWIG_From_unsigned_SS_long (value);
3508 }
3509
3510 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3511 wxImageHistogramEntry e = (*self)[key];
3512 return e.value;
3513 }
3514 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3515 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3516 wxImageHistogramEntry e = (*self)[key];
3517 return e.value;
3518 }
3519 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3520 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3521 colour.Green(),
3522 colour.Blue());
3523 wxImageHistogramEntry e = (*self)[key];
3524 return e.value;
3525 }
3526
3527 // Pull the nested class out to the top level for SWIG's sake
3528 #define wxImage_RGBValue wxImage::RGBValue
3529 #define wxImage_HSVValue wxImage::HSVValue
3530
3531 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3532 if (width > 0 && height > 0)
3533 return new wxImage(width, height, clear);
3534 else
3535 return new wxImage;
3536 }
3537 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3538 return new wxImage(bitmap.ConvertToImage());
3539 }
3540 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3541 if (DATASIZE != width*height*3) {
3542 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3543 return NULL;
3544 }
3545
3546 // Copy the source data so the wxImage can clean it up later
3547 buffer copy = (buffer)malloc(DATASIZE);
3548 if (copy == NULL) {
3549 wxPyBLOCK_THREADS(PyErr_NoMemory());
3550 return NULL;
3551 }
3552 memcpy(copy, data, DATASIZE);
3553 return new wxImage(width, height, copy, false);
3554 }
3555 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3556 if (DATASIZE != width*height*3) {
3557 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3558 return NULL;
3559 }
3560 if (ALPHASIZE != width*height) {
3561 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3562 return NULL;
3563 }
3564
3565 // Copy the source data so the wxImage can clean it up later
3566 buffer dcopy = (buffer)malloc(DATASIZE);
3567 if (dcopy == NULL) {
3568 wxPyBLOCK_THREADS(PyErr_NoMemory());
3569 return NULL;
3570 }
3571 memcpy(dcopy, data, DATASIZE);
3572
3573 buffer acopy = (buffer)malloc(ALPHASIZE);
3574 if (acopy == NULL) {
3575 wxPyBLOCK_THREADS(PyErr_NoMemory());
3576 return NULL;
3577 }
3578 memcpy(acopy, alpha, ALPHASIZE);
3579
3580 return new wxImage(width, height, dcopy, acopy, false);
3581 }
3582 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3583 wxSize size(self->GetWidth(), self->GetHeight());
3584 return size;
3585 }
3586 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3587 buffer data = self->GetData();
3588 int len = self->GetWidth() * self->GetHeight() * 3;
3589 PyObject* rv;
3590 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3591 return rv;
3592 }
3593 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3594 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3595 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3596 return;
3597 }
3598 buffer copy = (buffer)malloc(DATASIZE);
3599 if (copy == NULL) {
3600 wxPyBLOCK_THREADS(PyErr_NoMemory());
3601 return;
3602 }
3603 memcpy(copy, data, DATASIZE);
3604 self->SetData(copy, false);
3605 // wxImage takes ownership of copy...
3606 }
3607 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3608 buffer data = self->GetData();
3609 int len = self->GetWidth() * self->GetHeight() * 3;
3610 PyObject* rv;
3611 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3612 return rv;
3613 }
3614 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3615 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3616 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3617 return;
3618 }
3619 self->SetData(data, true);
3620 }
3621 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3622 buffer data = self->GetAlpha();
3623 if (! data) {
3624 RETURN_NONE();
3625 } else {
3626 int len = self->GetWidth() * self->GetHeight();
3627 PyObject* rv;
3628 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3629 return rv;
3630 }
3631 }
3632 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3633 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3634 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3635 return;
3636 }
3637 buffer acopy = (buffer)malloc(ALPHASIZE);
3638 if (acopy == NULL) {
3639 wxPyBLOCK_THREADS(PyErr_NoMemory());
3640 return;
3641 }
3642 memcpy(acopy, alpha, ALPHASIZE);
3643 self->SetAlpha(acopy, false);
3644 // wxImage takes ownership of acopy...
3645 }
3646 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3647 buffer data = self->GetAlpha();
3648 int len = self->GetWidth() * self->GetHeight();
3649 PyObject* rv;
3650 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3651 return rv;
3652 }
3653 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3654 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3655 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3656 return;
3657 }
3658 self->SetAlpha(alpha, true);
3659 }
3660 SWIGINTERN PyObject *wxImage_GetHandlers(){
3661 wxList& list = wxImage::GetHandlers();
3662 return wxPy_ConvertList(&list);
3663 }
3664 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3665 wxBitmap bitmap(*self, depth);
3666 return bitmap;
3667 }
3668 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3669 wxImage mono = self->ConvertToMono( red, green, blue );
3670 wxBitmap bitmap( mono, 1 );
3671 return bitmap;
3672 }
3673
3674 wxImage* _ImageFromBuffer(int width, int height,
3675 buffer data, int DATASIZE,
3676 buffer alpha=NULL, int ALPHASIZE=0)
3677 {
3678 if (DATASIZE != width*height*3) {
3679 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3680 return NULL;
3681 }
3682 if (alpha != NULL) {
3683 if (ALPHASIZE != width*height) {
3684 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3685 return NULL;
3686 }
3687 return new wxImage(width, height, data, alpha, true);
3688 }
3689 return new wxImage(width, height, data, true);
3690 }
3691
3692 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3693 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3694 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3695 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3696 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3697 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3698 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3699 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3700 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3701 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3702 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3703 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3704 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3705 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3706 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3707
3708 #include <wx/imagtga.h>
3709
3710
3711 #include <wx/quantize.h>
3712
3713 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3714 return wxQuantize::Quantize(src, dest,
3715 //NULL, // palette
3716 desiredNoColours,
3717 NULL, // eightBitData
3718 flags);
3719 }
3720 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3721 if (PyCallable_Check(func)) {
3722 self->Connect(id, lastId, eventType,
3723 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3724 new wxPyCallback(func));
3725 }
3726 else if (func == Py_None) {
3727 self->Disconnect(id, lastId, eventType,
3728 (wxObjectEventFunction)
3729 &wxPyCallback::EventThunker);
3730 }
3731 else {
3732 wxPyBLOCK_THREADS(
3733 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3734 }
3735 }
3736 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3737 return self->Disconnect(id, lastId, eventType,
3738 (wxObjectEventFunction)
3739 &wxPyCallback::EventThunker);
3740 }
3741 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3742 if (_self && _self != Py_None) {
3743 self->SetClientObject(new wxPyOORClientData(_self, incref));
3744 }
3745 else {
3746 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3747 if (data) {
3748 self->SetClientObject(NULL); // This will delete it too
3749 }
3750 }
3751 }
3752
3753 #if ! wxUSE_HOTKEY
3754 #define wxEVT_HOTKEY -9999
3755 #endif
3756
3757 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3758 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3759 if (data) {
3760 Py_INCREF(data->m_obj);
3761 return data->m_obj;
3762 } else {
3763 Py_INCREF(Py_None);
3764 return Py_None;
3765 }
3766 }
3767 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3768 wxPyClientData* data = new wxPyClientData(clientData);
3769 self->SetClientObject(data);
3770 }
3771 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3772 #if wxUSE_UNICODE
3773 return self->GetUnicodeKey();
3774 #else
3775 return 0;
3776 #endif
3777 }
3778 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3779 #if wxUSE_UNICODE
3780 self->m_uniChar = uniChar;
3781 #endif
3782 }
3783
3784 SWIGINTERNINLINE PyObject *
3785 SWIG_From_unsigned_SS_int (unsigned int value)
3786 {
3787 return SWIG_From_unsigned_SS_long (value);
3788 }
3789
3790
3791 SWIGINTERN int
3792 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3793 {
3794 unsigned long v;
3795 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3796 if (SWIG_IsOK(res)) {
3797 if ((v > UINT_MAX)) {
3798 return SWIG_OverflowError;
3799 } else {
3800 if (val) *val = static_cast< unsigned int >(v);
3801 }
3802 }
3803 return res;
3804 }
3805
3806 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3807 self->m_size = size;
3808 }
3809 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3810 int count = self->GetNumberOfFiles();
3811 wxString* files = self->GetFiles();
3812 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3813 PyObject* list = PyList_New(count);
3814
3815 if (!list) {
3816 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3817 wxPyEndBlockThreads(blocked);
3818 return NULL;
3819 }
3820
3821 for (int i=0; i<count; i++) {
3822 PyList_SetItem(list, i, wx2PyString(files[i]));
3823 }
3824 wxPyEndBlockThreads(blocked);
3825 return list;
3826 }
3827
3828
3829 SWIGINTERN wxPyApp *new_wxPyApp(){
3830 wxPythonApp = new wxPyApp();
3831 return wxPythonApp;
3832 }
3833 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3834 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3835 return wxPyTestDisplayAvailable();
3836 }
3837
3838 void wxApp_CleanUp() {
3839 __wxPyCleanup();
3840 }
3841
3842
3843 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3844
3845
3846
3847
3848
3849 SWIGINTERNINLINE PyObject *
3850 SWIG_FromCharPtr(const char *cptr)
3851 {
3852 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3853 }
3854
3855
3856 #if 0 // #ifdef __WXMAC__
3857
3858 // A dummy class that raises an exception if used...
3859 class wxEventLoop
3860 {
3861 public:
3862 wxEventLoop() { wxPyRaiseNotImplemented(); }
3863 int Run() { return 0; }
3864 void Exit(int rc = 0) {}
3865 bool Pending() const { return false; }
3866 bool Dispatch() { return false; }
3867 bool IsRunning() const { return false; }
3868 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3869 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3870 };
3871
3872 #else
3873
3874 #include <wx/evtloop.h>
3875
3876 #endif
3877
3878
3879
3880 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3881 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3882 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3883 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3884 wxWindowList& list = self->GetChildren();
3885 return wxPy_ConvertList(&list);
3886 }
3887 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3888 #if wxUSE_HOTKEY
3889 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3890 #else
3891 return false;
3892 #endif
3893 }
3894 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3895
3896
3897
3898 return false;
3899
3900 }
3901 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3902 return wxPyGetWinHandle(self);
3903 }
3904 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3905 self->AssociateHandle((WXWidget)handle);
3906 }
3907 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3908
3909 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3910 return wxWindow::FindWindowById(id, parent);
3911 }
3912
3913 wxWindow* wxFindWindowByName( const wxString& name,
3914 const wxWindow *parent = NULL ) {
3915 return wxWindow::FindWindowByName(name, parent);
3916 }
3917
3918 wxWindow* wxFindWindowByLabel( const wxString& label,
3919 const wxWindow *parent = NULL ) {
3920 return wxWindow::FindWindowByLabel(label, parent);
3921 }
3922
3923
3924 #ifdef __WXMSW__
3925 #include <wx/msw/private.h> // to get wxGetWindowId
3926 #endif
3927
3928
3929 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3930 #ifdef __WXMSW__
3931 WXHWND hWnd = (WXHWND)_hWnd;
3932 long id = wxGetWindowId(hWnd);
3933 wxWindow* win = new wxWindow;
3934 if (parent)
3935 parent->AddChild(win);
3936 win->SetEventHandler(win);
3937 win->SetHWND(hWnd);
3938 win->SetId(id);
3939 win->SubclassWin(hWnd);
3940 win->AdoptAttributesFromHWND();
3941 win->SetupColours();
3942 return win;
3943 #else
3944 wxPyRaiseNotImplemented();
3945 return NULL;
3946 #endif
3947 }
3948
3949
3950 PyObject* GetTopLevelWindows() {
3951 return wxPy_ConvertList(&wxTopLevelWindows);
3952 }
3953
3954
3955 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3956 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3957 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3958
3959 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3960
3961
3962 SWIGINTERNINLINE int
3963 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3964 {
3965 unsigned long v;
3966 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3967 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3968 return res;
3969 }
3970
3971 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3972 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3973 wxMenuItemList& list = self->GetMenuItems();
3974 return wxPy_ConvertList(&list);
3975 }
3976 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3977 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3978 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3979 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3980 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3981 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3982 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3983 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3984 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3985 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3986 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3987 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3988 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3989 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3990 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3991 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3992 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3993 static const wxString wxPyControlNameStr(wxControlNameStr);
3994 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3995 if (clientData) {
3996 wxPyClientData* data = new wxPyClientData(clientData);
3997 return self->Append(item, data);
3998 } else
3999 return self->Append(item);
4000 }
4001 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
4002 if (clientData) {
4003 wxPyClientData* data = new wxPyClientData(clientData);
4004 return self->Insert(item, pos, data);
4005 } else
4006 return self->Insert(item, pos);
4007 }
4008 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
4009 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
4010 if (data) {
4011 Py_INCREF(data->m_obj);
4012 return data->m_obj;
4013 } else {
4014 Py_INCREF(Py_None);
4015 return Py_None;
4016 }
4017 }
4018 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
4019 wxPyClientData* data = new wxPyClientData(clientData);
4020 self->SetClientObject(n, data);
4021 }
4022
4023
4024 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
4025 wxPyUserData* data = NULL;
4026 if ( userData ) {
4027 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4028 data = new wxPyUserData(userData);
4029 wxPyEndBlockThreads(blocked);
4030 }
4031 return new wxSizerItem(window, proportion, flag, border, data);
4032 }
4033 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
4034 wxPyUserData* data = NULL;
4035 if ( userData ) {
4036 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4037 data = new wxPyUserData(userData);
4038 wxPyEndBlockThreads(blocked);
4039 }
4040 return new wxSizerItem(width, height, proportion, flag, border, data);
4041 }
4042 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
4043 wxPyUserData* data = NULL;
4044 if ( userData ) {
4045 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4046 data = new wxPyUserData(userData);
4047 wxPyEndBlockThreads(blocked);
4048 }
4049 return new wxSizerItem(sizer, proportion, flag, border, data);
4050 }
4051
4052 SWIGINTERNINLINE PyObject *
4053 SWIG_From_float (float value)
4054 {
4055 return SWIG_From_double (value);
4056 }
4057
4058 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4059 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4060 if (data) {
4061 Py_INCREF(data->m_obj);
4062 return data->m_obj;
4063 } else {
4064 Py_INCREF(Py_None);
4065 return Py_None;
4066 }
4067 }
4068 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4069 wxPyUserData* data = NULL;
4070 if ( userData ) {
4071 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4072 data = new wxPyUserData(userData);
4073 wxPyEndBlockThreads(blocked);
4074 }
4075 self->SetUserData(data);
4076 }
4077
4078 // Figure out the type of the sizer item
4079
4080 struct wxPySizerItemInfo {
4081 wxPySizerItemInfo()
4082 : window(NULL), sizer(NULL), gotSize(false),
4083 size(wxDefaultSize), gotPos(false), pos(-1)
4084 {}
4085
4086 wxWindow* window;
4087 wxSizer* sizer;
4088 bool gotSize;
4089 wxSize size;
4090 bool gotPos;
4091 int pos;
4092 };
4093
4094 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4095
4096 wxPySizerItemInfo info;
4097 wxSize size;
4098 wxSize* sizePtr = &size;
4099
4100 // Find out what the type of the item is
4101 // try wxWindow
4102 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4103 PyErr_Clear();
4104 info.window = NULL;
4105
4106 // try wxSizer
4107 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4108 PyErr_Clear();
4109 info.sizer = NULL;
4110
4111 // try wxSize or (w,h)
4112 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4113 info.size = *sizePtr;
4114 info.gotSize = true;
4115 }
4116
4117 // or a single int
4118 if (checkIdx && PyInt_Check(item)) {
4119 info.pos = PyInt_AsLong(item);
4120 info.gotPos = true;
4121 }
4122 }
4123 }
4124
4125 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4126 // no expected type, figure out what kind of error message to generate
4127 if ( !checkSize && !checkIdx )
4128 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4129 else if ( checkSize && !checkIdx )
4130 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4131 else if ( !checkSize && checkIdx)
4132 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4133 else
4134 // can this one happen?
4135 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4136 }
4137
4138 return info;
4139 }
4140
4141 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4142 if (!self->GetClientObject())
4143 self->SetClientObject(new wxPyOORClientData(_self));
4144 }
4145 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4146
4147 wxPyUserData* data = NULL;
4148 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4149 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4150 if ( userData && (info.window || info.sizer || info.gotSize) )
4151 data = new wxPyUserData(userData);
4152 if ( info.sizer )
4153 PyObject_SetAttrString(item,"thisown",Py_False);
4154 wxPyEndBlockThreads(blocked);
4155
4156 // Now call the real Add method if a valid item type was found
4157 if ( info.window )
4158 return self->Add(info.window, proportion, flag, border, data);
4159 else if ( info.sizer )
4160 return self->Add(info.sizer, proportion, flag, border, data);
4161 else if (info.gotSize)
4162 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4163 proportion, flag, border, data);
4164 else
4165 return NULL;
4166 }
4167 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4168
4169 wxPyUserData* data = NULL;
4170 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4171 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4172 if ( userData && (info.window || info.sizer || info.gotSize) )
4173 data = new wxPyUserData(userData);
4174 if ( info.sizer )
4175 PyObject_SetAttrString(item,"thisown",Py_False);
4176 wxPyEndBlockThreads(blocked);
4177
4178 // Now call the real Insert method if a valid item type was found
4179 if ( info.window )
4180 return self->Insert(before, info.window, proportion, flag, border, data);
4181 else if ( info.sizer )
4182 return self->Insert(before, info.sizer, proportion, flag, border, data);
4183 else if (info.gotSize)
4184 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4185 proportion, flag, border, data);
4186 else
4187 return NULL;
4188 }
4189 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4190
4191 wxPyUserData* data = NULL;
4192 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4193 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4194 if ( userData && (info.window || info.sizer || info.gotSize) )
4195 data = new wxPyUserData(userData);
4196 if ( info.sizer )
4197 PyObject_SetAttrString(item,"thisown",Py_False);
4198 wxPyEndBlockThreads(blocked);
4199
4200 // Now call the real Prepend method if a valid item type was found
4201 if ( info.window )
4202 return self->Prepend(info.window, proportion, flag, border, data);
4203 else if ( info.sizer )
4204 return self->Prepend(info.sizer, proportion, flag, border, data);
4205 else if (info.gotSize)
4206 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4207 proportion, flag, border, data);
4208 else
4209 return NULL;
4210 }
4211 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4212 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4213 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4214 wxPyEndBlockThreads(blocked);
4215 if ( info.window )
4216 return self->Remove(info.window);
4217 else if ( info.sizer )
4218 return self->Remove(info.sizer);
4219 else if ( info.gotPos )
4220 return self->Remove(info.pos);
4221 else
4222 return false;
4223 }
4224 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4225 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4226 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4227 wxPyEndBlockThreads(blocked);
4228 if ( info.window )
4229 return self->Detach(info.window);
4230 else if ( info.sizer )
4231 return self->Detach(info.sizer);
4232 else if ( info.gotPos )
4233 return self->Detach(info.pos);
4234 else
4235 return false;
4236 }
4237 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4238 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4239 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4240 wxPyEndBlockThreads(blocked);
4241 if ( info.window )
4242 return self->GetItem(info.window);
4243 else if ( info.sizer )
4244 return self->GetItem(info.sizer);
4245 else if ( info.gotPos )
4246 return self->GetItem(info.pos);
4247 else
4248 return NULL;
4249 }
4250 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4251 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4252 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4253 wxPyEndBlockThreads(blocked);
4254 if ( info.window )
4255 self->SetItemMinSize(info.window, size);
4256 else if ( info.sizer )
4257 self->SetItemMinSize(info.sizer, size);
4258 else if ( info.gotPos )
4259 self->SetItemMinSize(info.pos, size);
4260 }
4261 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4262 wxSizerItemList& list = self->GetChildren();
4263 return wxPy_ConvertList(&list);
4264 }
4265 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4266 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4267 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4268 wxPyEndBlockThreads(blocked);
4269 if ( info.window )
4270 return self->Show(info.window, show, recursive);
4271 else if ( info.sizer )
4272 return self->Show(info.sizer, show, recursive);
4273 else if ( info.gotPos )
4274 return self->Show(info.pos, show);
4275 else
4276 return false;
4277 }
4278 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4279 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4280 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4281 wxPyEndBlockThreads(blocked);
4282 if ( info.window )
4283 return self->IsShown(info.window);
4284 else if ( info.sizer )
4285 return self->IsShown(info.sizer);
4286 else if ( info.gotPos )
4287 return self->IsShown(info.pos);
4288 else
4289 return false;
4290 }
4291
4292 // See pyclasses.h
4293 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4294 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4295 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4296
4297
4298
4299
4300 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4301 {
4302 if (source == Py_None) {
4303 **obj = wxGBPosition(-1,-1);
4304 return true;
4305 }
4306 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4307 }
4308
4309 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4310 {
4311 if (source == Py_None) {
4312 **obj = wxGBSpan(-1,-1);
4313 return true;
4314 }
4315 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4316 }
4317
4318
4319 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4320 wxGBPosition temp, *obj = &temp;
4321 if ( other == Py_None ) return false;
4322 if ( ! wxGBPosition_helper(other, &obj) ) {
4323 PyErr_Clear();
4324 return false;
4325 }
4326 return self->operator==(*obj);
4327 }
4328 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4329 wxGBPosition temp, *obj = &temp;
4330 if ( other == Py_None ) return true;
4331 if ( ! wxGBPosition_helper(other, &obj)) {
4332 PyErr_Clear();
4333 return true;
4334 }
4335 return self->operator!=(*obj);
4336 }
4337 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4338 self->SetRow(row);
4339 self->SetCol(col);
4340 }
4341 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4342 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4343 PyObject* tup = PyTuple_New(2);
4344 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4345 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4346 wxPyEndBlockThreads(blocked);
4347 return tup;
4348 }
4349 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4350 wxGBSpan temp, *obj = &temp;
4351 if ( other == Py_None ) return false;
4352 if ( ! wxGBSpan_helper(other, &obj) ) {
4353 PyErr_Clear();
4354 return false;
4355 }
4356 return self->operator==(*obj);
4357 }
4358 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4359 wxGBSpan temp, *obj = &temp;
4360 if ( other == Py_None ) return true;
4361 if ( ! wxGBSpan_helper(other, &obj)) {
4362 PyErr_Clear();
4363 return true;
4364 }
4365 return self->operator!=(*obj);
4366 }
4367 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4368 self->SetRowspan(rowspan);
4369 self->SetColspan(colspan);
4370 }
4371 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4372 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4373 PyObject* tup = PyTuple_New(2);
4374 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4375 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4376 wxPyEndBlockThreads(blocked);
4377 return tup;
4378 }
4379 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4380 wxPyUserData* data = NULL;
4381 if ( userData ) {
4382 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4383 data = new wxPyUserData(userData);
4384 wxPyEndBlockThreads(blocked);
4385 }
4386 return new wxGBSizerItem(window, pos, span, flag, border, data);
4387 }
4388 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4389 wxPyUserData* data = NULL;
4390 if ( userData ) {
4391 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4392 data = new wxPyUserData(userData);
4393 wxPyEndBlockThreads(blocked);
4394 }
4395 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4396 }
4397 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4398 wxPyUserData* data = NULL;
4399 if ( userData ) {
4400 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4401 data = new wxPyUserData(userData);
4402 wxPyEndBlockThreads(blocked);
4403 }
4404 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4405 }
4406 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4407 int row, col;
4408 self->GetEndPos(row, col);
4409 return wxGBPosition(row, col);
4410 }
4411 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4412
4413 wxPyUserData* data = NULL;
4414 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4415 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4416 if ( userData && (info.window || info.sizer || info.gotSize) )
4417 data = new wxPyUserData(userData);
4418 if ( info.sizer )
4419 PyObject_SetAttrString(item,"thisown",Py_False);
4420 wxPyEndBlockThreads(blocked);
4421
4422 // Now call the real Add method if a valid item type was found
4423 if ( info.window )
4424 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4425 else if ( info.sizer )
4426 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4427 else if (info.gotSize)
4428 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4429 pos, span, flag, border, data);
4430 return NULL;
4431 }
4432
4433
4434 #ifdef __cplusplus
4435 extern "C" {
4436 #endif
4437 SWIGINTERN int EmptyString_set(PyObject *) {
4438 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4439 return 1;
4440 }
4441
4442
4443 SWIGINTERN PyObject *EmptyString_get(void) {
4444 PyObject *pyobj = 0;
4445
4446 {
4447 #if wxUSE_UNICODE
4448 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4449 #else
4450 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4451 #endif
4452 }
4453 return pyobj;
4454 }
4455
4456
4457 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4458 PyObject *resultobj = 0;
4459 wxObject *arg1 = (wxObject *) 0 ;
4460 wxString result;
4461 void *argp1 = 0 ;
4462 int res1 = 0 ;
4463 PyObject *swig_obj[1] ;
4464
4465 if (!args) SWIG_fail;
4466 swig_obj[0] = args;
4467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4468 if (!SWIG_IsOK(res1)) {
4469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4470 }
4471 arg1 = reinterpret_cast< wxObject * >(argp1);
4472 {
4473 PyThreadState* __tstate = wxPyBeginAllowThreads();
4474 result = wxObject_GetClassName(arg1);
4475 wxPyEndAllowThreads(__tstate);
4476 if (PyErr_Occurred()) SWIG_fail;
4477 }
4478 {
4479 #if wxUSE_UNICODE
4480 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4481 #else
4482 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4483 #endif
4484 }
4485 return resultobj;
4486 fail:
4487 return NULL;
4488 }
4489
4490
4491 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4492 PyObject *resultobj = 0;
4493 wxObject *arg1 = (wxObject *) 0 ;
4494 void *argp1 = 0 ;
4495 int res1 = 0 ;
4496 PyObject *swig_obj[1] ;
4497
4498 if (!args) SWIG_fail;
4499 swig_obj[0] = args;
4500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4501 if (!SWIG_IsOK(res1)) {
4502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4503 }
4504 arg1 = reinterpret_cast< wxObject * >(argp1);
4505 {
4506 PyThreadState* __tstate = wxPyBeginAllowThreads();
4507 wxObject_Destroy(arg1);
4508 wxPyEndAllowThreads(__tstate);
4509 if (PyErr_Occurred()) SWIG_fail;
4510 }
4511 resultobj = SWIG_Py_Void();
4512 return resultobj;
4513 fail:
4514 return NULL;
4515 }
4516
4517
4518 SWIGINTERN PyObject *_wrap_Object_IsSameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4519 PyObject *resultobj = 0;
4520 wxObject *arg1 = (wxObject *) 0 ;
4521 wxObject *arg2 = 0 ;
4522 bool result;
4523 void *argp1 = 0 ;
4524 int res1 = 0 ;
4525 void *argp2 = 0 ;
4526 int res2 = 0 ;
4527 PyObject * obj0 = 0 ;
4528 PyObject * obj1 = 0 ;
4529 char * kwnames[] = {
4530 (char *) "self",(char *) "p", NULL
4531 };
4532
4533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Object_IsSameAs",kwnames,&obj0,&obj1)) SWIG_fail;
4534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4535 if (!SWIG_IsOK(res1)) {
4536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_IsSameAs" "', expected argument " "1"" of type '" "wxObject const *""'");
4537 }
4538 arg1 = reinterpret_cast< wxObject * >(argp1);
4539 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxObject, 0 | 0);
4540 if (!SWIG_IsOK(res2)) {
4541 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4542 }
4543 if (!argp2) {
4544 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4545 }
4546 arg2 = reinterpret_cast< wxObject * >(argp2);
4547 {
4548 PyThreadState* __tstate = wxPyBeginAllowThreads();
4549 result = (bool)((wxObject const *)arg1)->IsSameAs((wxObject const &)*arg2);
4550 wxPyEndAllowThreads(__tstate);
4551 if (PyErr_Occurred()) SWIG_fail;
4552 }
4553 {
4554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4555 }
4556 return resultobj;
4557 fail:
4558 return NULL;
4559 }
4560
4561
4562 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4563 PyObject *obj;
4564 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4565 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4566 return SWIG_Py_Void();
4567 }
4568
4569 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4570 PyObject *resultobj = 0;
4571 wxSize *arg1 = (wxSize *) 0 ;
4572 int arg2 ;
4573 void *argp1 = 0 ;
4574 int res1 = 0 ;
4575 int val2 ;
4576 int ecode2 = 0 ;
4577 PyObject *swig_obj[2] ;
4578
4579 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4581 if (!SWIG_IsOK(res1)) {
4582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4583 }
4584 arg1 = reinterpret_cast< wxSize * >(argp1);
4585 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4586 if (!SWIG_IsOK(ecode2)) {
4587 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4588 }
4589 arg2 = static_cast< int >(val2);
4590 if (arg1) (arg1)->x = arg2;
4591
4592 resultobj = SWIG_Py_Void();
4593 return resultobj;
4594 fail:
4595 return NULL;
4596 }
4597
4598
4599 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4600 PyObject *resultobj = 0;
4601 wxSize *arg1 = (wxSize *) 0 ;
4602 int result;
4603 void *argp1 = 0 ;
4604 int res1 = 0 ;
4605 PyObject *swig_obj[1] ;
4606
4607 if (!args) SWIG_fail;
4608 swig_obj[0] = args;
4609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4610 if (!SWIG_IsOK(res1)) {
4611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4612 }
4613 arg1 = reinterpret_cast< wxSize * >(argp1);
4614 result = (int) ((arg1)->x);
4615 resultobj = SWIG_From_int(static_cast< int >(result));
4616 return resultobj;
4617 fail:
4618 return NULL;
4619 }
4620
4621
4622 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4623 PyObject *resultobj = 0;
4624 wxSize *arg1 = (wxSize *) 0 ;
4625 int arg2 ;
4626 void *argp1 = 0 ;
4627 int res1 = 0 ;
4628 int val2 ;
4629 int ecode2 = 0 ;
4630 PyObject *swig_obj[2] ;
4631
4632 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4634 if (!SWIG_IsOK(res1)) {
4635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4636 }
4637 arg1 = reinterpret_cast< wxSize * >(argp1);
4638 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4639 if (!SWIG_IsOK(ecode2)) {
4640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4641 }
4642 arg2 = static_cast< int >(val2);
4643 if (arg1) (arg1)->y = arg2;
4644
4645 resultobj = SWIG_Py_Void();
4646 return resultobj;
4647 fail:
4648 return NULL;
4649 }
4650
4651
4652 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4653 PyObject *resultobj = 0;
4654 wxSize *arg1 = (wxSize *) 0 ;
4655 int result;
4656 void *argp1 = 0 ;
4657 int res1 = 0 ;
4658 PyObject *swig_obj[1] ;
4659
4660 if (!args) SWIG_fail;
4661 swig_obj[0] = args;
4662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4663 if (!SWIG_IsOK(res1)) {
4664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4665 }
4666 arg1 = reinterpret_cast< wxSize * >(argp1);
4667 result = (int) ((arg1)->y);
4668 resultobj = SWIG_From_int(static_cast< int >(result));
4669 return resultobj;
4670 fail:
4671 return NULL;
4672 }
4673
4674
4675 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4676 PyObject *resultobj = 0;
4677 int arg1 = (int) 0 ;
4678 int arg2 = (int) 0 ;
4679 wxSize *result = 0 ;
4680 int val1 ;
4681 int ecode1 = 0 ;
4682 int val2 ;
4683 int ecode2 = 0 ;
4684 PyObject * obj0 = 0 ;
4685 PyObject * obj1 = 0 ;
4686 char * kwnames[] = {
4687 (char *) "w",(char *) "h", NULL
4688 };
4689
4690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4691 if (obj0) {
4692 ecode1 = SWIG_AsVal_int(obj0, &val1);
4693 if (!SWIG_IsOK(ecode1)) {
4694 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4695 }
4696 arg1 = static_cast< int >(val1);
4697 }
4698 if (obj1) {
4699 ecode2 = SWIG_AsVal_int(obj1, &val2);
4700 if (!SWIG_IsOK(ecode2)) {
4701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4702 }
4703 arg2 = static_cast< int >(val2);
4704 }
4705 {
4706 result = (wxSize *)new wxSize(arg1,arg2);
4707 if (PyErr_Occurred()) SWIG_fail;
4708 }
4709 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4710 return resultobj;
4711 fail:
4712 return NULL;
4713 }
4714
4715
4716 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4717 PyObject *resultobj = 0;
4718 wxSize *arg1 = (wxSize *) 0 ;
4719 void *argp1 = 0 ;
4720 int res1 = 0 ;
4721 PyObject *swig_obj[1] ;
4722
4723 if (!args) SWIG_fail;
4724 swig_obj[0] = args;
4725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4726 if (!SWIG_IsOK(res1)) {
4727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4728 }
4729 arg1 = reinterpret_cast< wxSize * >(argp1);
4730 {
4731 delete arg1;
4732
4733 if (PyErr_Occurred()) SWIG_fail;
4734 }
4735 resultobj = SWIG_Py_Void();
4736 return resultobj;
4737 fail:
4738 return NULL;
4739 }
4740
4741
4742 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4743 PyObject *resultobj = 0;
4744 wxSize *arg1 = (wxSize *) 0 ;
4745 PyObject *arg2 = (PyObject *) 0 ;
4746 bool result;
4747 void *argp1 = 0 ;
4748 int res1 = 0 ;
4749 PyObject * obj0 = 0 ;
4750 PyObject * obj1 = 0 ;
4751 char * kwnames[] = {
4752 (char *) "self",(char *) "other", NULL
4753 };
4754
4755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4757 if (!SWIG_IsOK(res1)) {
4758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4759 }
4760 arg1 = reinterpret_cast< wxSize * >(argp1);
4761 arg2 = obj1;
4762 {
4763 result = (bool)wxSize___eq__(arg1,arg2);
4764 if (PyErr_Occurred()) SWIG_fail;
4765 }
4766 {
4767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4768 }
4769 return resultobj;
4770 fail:
4771 return NULL;
4772 }
4773
4774
4775 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4776 PyObject *resultobj = 0;
4777 wxSize *arg1 = (wxSize *) 0 ;
4778 PyObject *arg2 = (PyObject *) 0 ;
4779 bool result;
4780 void *argp1 = 0 ;
4781 int res1 = 0 ;
4782 PyObject * obj0 = 0 ;
4783 PyObject * obj1 = 0 ;
4784 char * kwnames[] = {
4785 (char *) "self",(char *) "other", NULL
4786 };
4787
4788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4790 if (!SWIG_IsOK(res1)) {
4791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4792 }
4793 arg1 = reinterpret_cast< wxSize * >(argp1);
4794 arg2 = obj1;
4795 {
4796 result = (bool)wxSize___ne__(arg1,arg2);
4797 if (PyErr_Occurred()) SWIG_fail;
4798 }
4799 {
4800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4801 }
4802 return resultobj;
4803 fail:
4804 return NULL;
4805 }
4806
4807
4808 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4809 PyObject *resultobj = 0;
4810 wxSize *arg1 = (wxSize *) 0 ;
4811 wxSize *arg2 = 0 ;
4812 wxSize result;
4813 void *argp1 = 0 ;
4814 int res1 = 0 ;
4815 wxSize temp2 ;
4816 PyObject * obj0 = 0 ;
4817 PyObject * obj1 = 0 ;
4818 char * kwnames[] = {
4819 (char *) "self",(char *) "sz", NULL
4820 };
4821
4822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4824 if (!SWIG_IsOK(res1)) {
4825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4826 }
4827 arg1 = reinterpret_cast< wxSize * >(argp1);
4828 {
4829 arg2 = &temp2;
4830 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4831 }
4832 {
4833 result = (arg1)->operator +((wxSize const &)*arg2);
4834 if (PyErr_Occurred()) SWIG_fail;
4835 }
4836 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4837 return resultobj;
4838 fail:
4839 return NULL;
4840 }
4841
4842
4843 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4844 PyObject *resultobj = 0;
4845 wxSize *arg1 = (wxSize *) 0 ;
4846 wxSize *arg2 = 0 ;
4847 wxSize result;
4848 void *argp1 = 0 ;
4849 int res1 = 0 ;
4850 wxSize temp2 ;
4851 PyObject * obj0 = 0 ;
4852 PyObject * obj1 = 0 ;
4853 char * kwnames[] = {
4854 (char *) "self",(char *) "sz", NULL
4855 };
4856
4857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4859 if (!SWIG_IsOK(res1)) {
4860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4861 }
4862 arg1 = reinterpret_cast< wxSize * >(argp1);
4863 {
4864 arg2 = &temp2;
4865 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4866 }
4867 {
4868 result = (arg1)->operator -((wxSize const &)*arg2);
4869 if (PyErr_Occurred()) SWIG_fail;
4870 }
4871 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4872 return resultobj;
4873 fail:
4874 return NULL;
4875 }
4876
4877
4878 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4879 PyObject *resultobj = 0;
4880 wxSize *arg1 = (wxSize *) 0 ;
4881 wxSize *arg2 = 0 ;
4882 void *argp1 = 0 ;
4883 int res1 = 0 ;
4884 wxSize temp2 ;
4885 PyObject * obj0 = 0 ;
4886 PyObject * obj1 = 0 ;
4887 char * kwnames[] = {
4888 (char *) "self",(char *) "sz", NULL
4889 };
4890
4891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4893 if (!SWIG_IsOK(res1)) {
4894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4895 }
4896 arg1 = reinterpret_cast< wxSize * >(argp1);
4897 {
4898 arg2 = &temp2;
4899 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4900 }
4901 {
4902 (arg1)->IncTo((wxSize const &)*arg2);
4903 if (PyErr_Occurred()) SWIG_fail;
4904 }
4905 resultobj = SWIG_Py_Void();
4906 return resultobj;
4907 fail:
4908 return NULL;
4909 }
4910
4911
4912 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4913 PyObject *resultobj = 0;
4914 wxSize *arg1 = (wxSize *) 0 ;
4915 wxSize *arg2 = 0 ;
4916 void *argp1 = 0 ;
4917 int res1 = 0 ;
4918 wxSize temp2 ;
4919 PyObject * obj0 = 0 ;
4920 PyObject * obj1 = 0 ;
4921 char * kwnames[] = {
4922 (char *) "self",(char *) "sz", NULL
4923 };
4924
4925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4927 if (!SWIG_IsOK(res1)) {
4928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4929 }
4930 arg1 = reinterpret_cast< wxSize * >(argp1);
4931 {
4932 arg2 = &temp2;
4933 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4934 }
4935 {
4936 (arg1)->DecTo((wxSize const &)*arg2);
4937 if (PyErr_Occurred()) SWIG_fail;
4938 }
4939 resultobj = SWIG_Py_Void();
4940 return resultobj;
4941 fail:
4942 return NULL;
4943 }
4944
4945
4946 SWIGINTERN PyObject *_wrap_Size_IncBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4947 PyObject *resultobj = 0;
4948 wxSize *arg1 = (wxSize *) 0 ;
4949 int arg2 ;
4950 int arg3 ;
4951 void *argp1 = 0 ;
4952 int res1 = 0 ;
4953 int val2 ;
4954 int ecode2 = 0 ;
4955 int val3 ;
4956 int ecode3 = 0 ;
4957 PyObject * obj0 = 0 ;
4958 PyObject * obj1 = 0 ;
4959 PyObject * obj2 = 0 ;
4960 char * kwnames[] = {
4961 (char *) "self",(char *) "dx",(char *) "dy", NULL
4962 };
4963
4964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_IncBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4966 if (!SWIG_IsOK(res1)) {
4967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncBy" "', expected argument " "1"" of type '" "wxSize *""'");
4968 }
4969 arg1 = reinterpret_cast< wxSize * >(argp1);
4970 ecode2 = SWIG_AsVal_int(obj1, &val2);
4971 if (!SWIG_IsOK(ecode2)) {
4972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_IncBy" "', expected argument " "2"" of type '" "int""'");
4973 }
4974 arg2 = static_cast< int >(val2);
4975 ecode3 = SWIG_AsVal_int(obj2, &val3);
4976 if (!SWIG_IsOK(ecode3)) {
4977 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_IncBy" "', expected argument " "3"" of type '" "int""'");
4978 }
4979 arg3 = static_cast< int >(val3);
4980 {
4981 (arg1)->IncBy(arg2,arg3);
4982 if (PyErr_Occurred()) SWIG_fail;
4983 }
4984 resultobj = SWIG_Py_Void();
4985 return resultobj;
4986 fail:
4987 return NULL;
4988 }
4989
4990
4991 SWIGINTERN PyObject *_wrap_Size_DecBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4992 PyObject *resultobj = 0;
4993 wxSize *arg1 = (wxSize *) 0 ;
4994 int arg2 ;
4995 int arg3 ;
4996 void *argp1 = 0 ;
4997 int res1 = 0 ;
4998 int val2 ;
4999 int ecode2 = 0 ;
5000 int val3 ;
5001 int ecode3 = 0 ;
5002 PyObject * obj0 = 0 ;
5003 PyObject * obj1 = 0 ;
5004 PyObject * obj2 = 0 ;
5005 char * kwnames[] = {
5006 (char *) "self",(char *) "dx",(char *) "dy", NULL
5007 };
5008
5009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_DecBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5011 if (!SWIG_IsOK(res1)) {
5012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecBy" "', expected argument " "1"" of type '" "wxSize *""'");
5013 }
5014 arg1 = reinterpret_cast< wxSize * >(argp1);
5015 ecode2 = SWIG_AsVal_int(obj1, &val2);
5016 if (!SWIG_IsOK(ecode2)) {
5017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_DecBy" "', expected argument " "2"" of type '" "int""'");
5018 }
5019 arg2 = static_cast< int >(val2);
5020 ecode3 = SWIG_AsVal_int(obj2, &val3);
5021 if (!SWIG_IsOK(ecode3)) {
5022 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_DecBy" "', expected argument " "3"" of type '" "int""'");
5023 }
5024 arg3 = static_cast< int >(val3);
5025 {
5026 (arg1)->DecBy(arg2,arg3);
5027 if (PyErr_Occurred()) SWIG_fail;
5028 }
5029 resultobj = SWIG_Py_Void();
5030 return resultobj;
5031 fail:
5032 return NULL;
5033 }
5034
5035
5036 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5037 PyObject *resultobj = 0;
5038 wxSize *arg1 = (wxSize *) 0 ;
5039 float arg2 ;
5040 float arg3 ;
5041 void *argp1 = 0 ;
5042 int res1 = 0 ;
5043 float val2 ;
5044 int ecode2 = 0 ;
5045 float val3 ;
5046 int ecode3 = 0 ;
5047 PyObject * obj0 = 0 ;
5048 PyObject * obj1 = 0 ;
5049 PyObject * obj2 = 0 ;
5050 char * kwnames[] = {
5051 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
5052 };
5053
5054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5056 if (!SWIG_IsOK(res1)) {
5057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
5058 }
5059 arg1 = reinterpret_cast< wxSize * >(argp1);
5060 ecode2 = SWIG_AsVal_float(obj1, &val2);
5061 if (!SWIG_IsOK(ecode2)) {
5062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
5063 }
5064 arg2 = static_cast< float >(val2);
5065 ecode3 = SWIG_AsVal_float(obj2, &val3);
5066 if (!SWIG_IsOK(ecode3)) {
5067 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
5068 }
5069 arg3 = static_cast< float >(val3);
5070 {
5071 (arg1)->Scale(arg2,arg3);
5072 if (PyErr_Occurred()) SWIG_fail;
5073 }
5074 resultobj = SWIG_Py_Void();
5075 return resultobj;
5076 fail:
5077 return NULL;
5078 }
5079
5080
5081 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5082 PyObject *resultobj = 0;
5083 wxSize *arg1 = (wxSize *) 0 ;
5084 int arg2 ;
5085 int arg3 ;
5086 void *argp1 = 0 ;
5087 int res1 = 0 ;
5088 int val2 ;
5089 int ecode2 = 0 ;
5090 int val3 ;
5091 int ecode3 = 0 ;
5092 PyObject * obj0 = 0 ;
5093 PyObject * obj1 = 0 ;
5094 PyObject * obj2 = 0 ;
5095 char * kwnames[] = {
5096 (char *) "self",(char *) "w",(char *) "h", NULL
5097 };
5098
5099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5101 if (!SWIG_IsOK(res1)) {
5102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
5103 }
5104 arg1 = reinterpret_cast< wxSize * >(argp1);
5105 ecode2 = SWIG_AsVal_int(obj1, &val2);
5106 if (!SWIG_IsOK(ecode2)) {
5107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
5108 }
5109 arg2 = static_cast< int >(val2);
5110 ecode3 = SWIG_AsVal_int(obj2, &val3);
5111 if (!SWIG_IsOK(ecode3)) {
5112 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
5113 }
5114 arg3 = static_cast< int >(val3);
5115 {
5116 (arg1)->Set(arg2,arg3);
5117 if (PyErr_Occurred()) SWIG_fail;
5118 }
5119 resultobj = SWIG_Py_Void();
5120 return resultobj;
5121 fail:
5122 return NULL;
5123 }
5124
5125
5126 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5127 PyObject *resultobj = 0;
5128 wxSize *arg1 = (wxSize *) 0 ;
5129 int arg2 ;
5130 void *argp1 = 0 ;
5131 int res1 = 0 ;
5132 int val2 ;
5133 int ecode2 = 0 ;
5134 PyObject * obj0 = 0 ;
5135 PyObject * obj1 = 0 ;
5136 char * kwnames[] = {
5137 (char *) "self",(char *) "w", NULL
5138 };
5139
5140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5142 if (!SWIG_IsOK(res1)) {
5143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
5144 }
5145 arg1 = reinterpret_cast< wxSize * >(argp1);
5146 ecode2 = SWIG_AsVal_int(obj1, &val2);
5147 if (!SWIG_IsOK(ecode2)) {
5148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
5149 }
5150 arg2 = static_cast< int >(val2);
5151 {
5152 (arg1)->SetWidth(arg2);
5153 if (PyErr_Occurred()) SWIG_fail;
5154 }
5155 resultobj = SWIG_Py_Void();
5156 return resultobj;
5157 fail:
5158 return NULL;
5159 }
5160
5161
5162 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5163 PyObject *resultobj = 0;
5164 wxSize *arg1 = (wxSize *) 0 ;
5165 int arg2 ;
5166 void *argp1 = 0 ;
5167 int res1 = 0 ;
5168 int val2 ;
5169 int ecode2 = 0 ;
5170 PyObject * obj0 = 0 ;
5171 PyObject * obj1 = 0 ;
5172 char * kwnames[] = {
5173 (char *) "self",(char *) "h", NULL
5174 };
5175
5176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5178 if (!SWIG_IsOK(res1)) {
5179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5180 }
5181 arg1 = reinterpret_cast< wxSize * >(argp1);
5182 ecode2 = SWIG_AsVal_int(obj1, &val2);
5183 if (!SWIG_IsOK(ecode2)) {
5184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5185 }
5186 arg2 = static_cast< int >(val2);
5187 {
5188 (arg1)->SetHeight(arg2);
5189 if (PyErr_Occurred()) SWIG_fail;
5190 }
5191 resultobj = SWIG_Py_Void();
5192 return resultobj;
5193 fail:
5194 return NULL;
5195 }
5196
5197
5198 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5199 PyObject *resultobj = 0;
5200 wxSize *arg1 = (wxSize *) 0 ;
5201 int result;
5202 void *argp1 = 0 ;
5203 int res1 = 0 ;
5204 PyObject *swig_obj[1] ;
5205
5206 if (!args) SWIG_fail;
5207 swig_obj[0] = args;
5208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5209 if (!SWIG_IsOK(res1)) {
5210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5211 }
5212 arg1 = reinterpret_cast< wxSize * >(argp1);
5213 {
5214 result = (int)((wxSize const *)arg1)->GetWidth();
5215 if (PyErr_Occurred()) SWIG_fail;
5216 }
5217 resultobj = SWIG_From_int(static_cast< int >(result));
5218 return resultobj;
5219 fail:
5220 return NULL;
5221 }
5222
5223
5224 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5225 PyObject *resultobj = 0;
5226 wxSize *arg1 = (wxSize *) 0 ;
5227 int result;
5228 void *argp1 = 0 ;
5229 int res1 = 0 ;
5230 PyObject *swig_obj[1] ;
5231
5232 if (!args) SWIG_fail;
5233 swig_obj[0] = args;
5234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5235 if (!SWIG_IsOK(res1)) {
5236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5237 }
5238 arg1 = reinterpret_cast< wxSize * >(argp1);
5239 {
5240 result = (int)((wxSize const *)arg1)->GetHeight();
5241 if (PyErr_Occurred()) SWIG_fail;
5242 }
5243 resultobj = SWIG_From_int(static_cast< int >(result));
5244 return resultobj;
5245 fail:
5246 return NULL;
5247 }
5248
5249
5250 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5251 PyObject *resultobj = 0;
5252 wxSize *arg1 = (wxSize *) 0 ;
5253 bool result;
5254 void *argp1 = 0 ;
5255 int res1 = 0 ;
5256 PyObject *swig_obj[1] ;
5257
5258 if (!args) SWIG_fail;
5259 swig_obj[0] = args;
5260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5261 if (!SWIG_IsOK(res1)) {
5262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5263 }
5264 arg1 = reinterpret_cast< wxSize * >(argp1);
5265 {
5266 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5267 if (PyErr_Occurred()) SWIG_fail;
5268 }
5269 {
5270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5271 }
5272 return resultobj;
5273 fail:
5274 return NULL;
5275 }
5276
5277
5278 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5279 PyObject *resultobj = 0;
5280 wxSize *arg1 = (wxSize *) 0 ;
5281 wxSize *arg2 = 0 ;
5282 void *argp1 = 0 ;
5283 int res1 = 0 ;
5284 wxSize temp2 ;
5285 PyObject * obj0 = 0 ;
5286 PyObject * obj1 = 0 ;
5287 char * kwnames[] = {
5288 (char *) "self",(char *) "size", NULL
5289 };
5290
5291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5293 if (!SWIG_IsOK(res1)) {
5294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5295 }
5296 arg1 = reinterpret_cast< wxSize * >(argp1);
5297 {
5298 arg2 = &temp2;
5299 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5300 }
5301 {
5302 (arg1)->SetDefaults((wxSize const &)*arg2);
5303 if (PyErr_Occurred()) SWIG_fail;
5304 }
5305 resultobj = SWIG_Py_Void();
5306 return resultobj;
5307 fail:
5308 return NULL;
5309 }
5310
5311
5312 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5313 PyObject *resultobj = 0;
5314 wxSize *arg1 = (wxSize *) 0 ;
5315 PyObject *result = 0 ;
5316 void *argp1 = 0 ;
5317 int res1 = 0 ;
5318 PyObject *swig_obj[1] ;
5319
5320 if (!args) SWIG_fail;
5321 swig_obj[0] = args;
5322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5323 if (!SWIG_IsOK(res1)) {
5324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5325 }
5326 arg1 = reinterpret_cast< wxSize * >(argp1);
5327 {
5328 result = (PyObject *)wxSize_Get(arg1);
5329 if (PyErr_Occurred()) SWIG_fail;
5330 }
5331 resultobj = result;
5332 return resultobj;
5333 fail:
5334 return NULL;
5335 }
5336
5337
5338 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5339 PyObject *obj;
5340 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5341 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5342 return SWIG_Py_Void();
5343 }
5344
5345 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5346 return SWIG_Python_InitShadowInstance(args);
5347 }
5348
5349 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5350 PyObject *resultobj = 0;
5351 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5352 double arg2 ;
5353 void *argp1 = 0 ;
5354 int res1 = 0 ;
5355 double val2 ;
5356 int ecode2 = 0 ;
5357 PyObject *swig_obj[2] ;
5358
5359 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5361 if (!SWIG_IsOK(res1)) {
5362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5363 }
5364 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5365 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5366 if (!SWIG_IsOK(ecode2)) {
5367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5368 }
5369 arg2 = static_cast< double >(val2);
5370 if (arg1) (arg1)->x = arg2;
5371
5372 resultobj = SWIG_Py_Void();
5373 return resultobj;
5374 fail:
5375 return NULL;
5376 }
5377
5378
5379 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5380 PyObject *resultobj = 0;
5381 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5382 double result;
5383 void *argp1 = 0 ;
5384 int res1 = 0 ;
5385 PyObject *swig_obj[1] ;
5386
5387 if (!args) SWIG_fail;
5388 swig_obj[0] = args;
5389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5390 if (!SWIG_IsOK(res1)) {
5391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5392 }
5393 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5394 result = (double) ((arg1)->x);
5395 resultobj = SWIG_From_double(static_cast< double >(result));
5396 return resultobj;
5397 fail:
5398 return NULL;
5399 }
5400
5401
5402 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5403 PyObject *resultobj = 0;
5404 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5405 double arg2 ;
5406 void *argp1 = 0 ;
5407 int res1 = 0 ;
5408 double val2 ;
5409 int ecode2 = 0 ;
5410 PyObject *swig_obj[2] ;
5411
5412 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5414 if (!SWIG_IsOK(res1)) {
5415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5416 }
5417 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5418 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5419 if (!SWIG_IsOK(ecode2)) {
5420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5421 }
5422 arg2 = static_cast< double >(val2);
5423 if (arg1) (arg1)->y = arg2;
5424
5425 resultobj = SWIG_Py_Void();
5426 return resultobj;
5427 fail:
5428 return NULL;
5429 }
5430
5431
5432 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5433 PyObject *resultobj = 0;
5434 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5435 double result;
5436 void *argp1 = 0 ;
5437 int res1 = 0 ;
5438 PyObject *swig_obj[1] ;
5439
5440 if (!args) SWIG_fail;
5441 swig_obj[0] = args;
5442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5443 if (!SWIG_IsOK(res1)) {
5444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5445 }
5446 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5447 result = (double) ((arg1)->y);
5448 resultobj = SWIG_From_double(static_cast< double >(result));
5449 return resultobj;
5450 fail:
5451 return NULL;
5452 }
5453
5454
5455 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5456 PyObject *resultobj = 0;
5457 double arg1 = (double) 0.0 ;
5458 double arg2 = (double) 0.0 ;
5459 wxRealPoint *result = 0 ;
5460 double val1 ;
5461 int ecode1 = 0 ;
5462 double val2 ;
5463 int ecode2 = 0 ;
5464 PyObject * obj0 = 0 ;
5465 PyObject * obj1 = 0 ;
5466 char * kwnames[] = {
5467 (char *) "x",(char *) "y", NULL
5468 };
5469
5470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5471 if (obj0) {
5472 ecode1 = SWIG_AsVal_double(obj0, &val1);
5473 if (!SWIG_IsOK(ecode1)) {
5474 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5475 }
5476 arg1 = static_cast< double >(val1);
5477 }
5478 if (obj1) {
5479 ecode2 = SWIG_AsVal_double(obj1, &val2);
5480 if (!SWIG_IsOK(ecode2)) {
5481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5482 }
5483 arg2 = static_cast< double >(val2);
5484 }
5485 {
5486 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5487 if (PyErr_Occurred()) SWIG_fail;
5488 }
5489 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5490 return resultobj;
5491 fail:
5492 return NULL;
5493 }
5494
5495
5496 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5497 PyObject *resultobj = 0;
5498 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5499 void *argp1 = 0 ;
5500 int res1 = 0 ;
5501 PyObject *swig_obj[1] ;
5502
5503 if (!args) SWIG_fail;
5504 swig_obj[0] = args;
5505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5506 if (!SWIG_IsOK(res1)) {
5507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5508 }
5509 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5510 {
5511 delete arg1;
5512
5513 if (PyErr_Occurred()) SWIG_fail;
5514 }
5515 resultobj = SWIG_Py_Void();
5516 return resultobj;
5517 fail:
5518 return NULL;
5519 }
5520
5521
5522 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5523 PyObject *resultobj = 0;
5524 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5525 PyObject *arg2 = (PyObject *) 0 ;
5526 bool result;
5527 void *argp1 = 0 ;
5528 int res1 = 0 ;
5529 PyObject * obj0 = 0 ;
5530 PyObject * obj1 = 0 ;
5531 char * kwnames[] = {
5532 (char *) "self",(char *) "other", NULL
5533 };
5534
5535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5537 if (!SWIG_IsOK(res1)) {
5538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5539 }
5540 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5541 arg2 = obj1;
5542 {
5543 result = (bool)wxRealPoint___eq__(arg1,arg2);
5544 if (PyErr_Occurred()) SWIG_fail;
5545 }
5546 {
5547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5548 }
5549 return resultobj;
5550 fail:
5551 return NULL;
5552 }
5553
5554
5555 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5556 PyObject *resultobj = 0;
5557 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5558 PyObject *arg2 = (PyObject *) 0 ;
5559 bool result;
5560 void *argp1 = 0 ;
5561 int res1 = 0 ;
5562 PyObject * obj0 = 0 ;
5563 PyObject * obj1 = 0 ;
5564 char * kwnames[] = {
5565 (char *) "self",(char *) "other", NULL
5566 };
5567
5568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5570 if (!SWIG_IsOK(res1)) {
5571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5572 }
5573 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5574 arg2 = obj1;
5575 {
5576 result = (bool)wxRealPoint___ne__(arg1,arg2);
5577 if (PyErr_Occurred()) SWIG_fail;
5578 }
5579 {
5580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5581 }
5582 return resultobj;
5583 fail:
5584 return NULL;
5585 }
5586
5587
5588 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5589 PyObject *resultobj = 0;
5590 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5591 wxRealPoint *arg2 = 0 ;
5592 wxRealPoint result;
5593 void *argp1 = 0 ;
5594 int res1 = 0 ;
5595 wxRealPoint temp2 ;
5596 PyObject * obj0 = 0 ;
5597 PyObject * obj1 = 0 ;
5598 char * kwnames[] = {
5599 (char *) "self",(char *) "pt", NULL
5600 };
5601
5602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5604 if (!SWIG_IsOK(res1)) {
5605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5606 }
5607 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5608 {
5609 arg2 = &temp2;
5610 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5611 }
5612 {
5613 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5614 if (PyErr_Occurred()) SWIG_fail;
5615 }
5616 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5617 return resultobj;
5618 fail:
5619 return NULL;
5620 }
5621
5622
5623 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5624 PyObject *resultobj = 0;
5625 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5626 wxRealPoint *arg2 = 0 ;
5627 wxRealPoint result;
5628 void *argp1 = 0 ;
5629 int res1 = 0 ;
5630 wxRealPoint temp2 ;
5631 PyObject * obj0 = 0 ;
5632 PyObject * obj1 = 0 ;
5633 char * kwnames[] = {
5634 (char *) "self",(char *) "pt", NULL
5635 };
5636
5637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5639 if (!SWIG_IsOK(res1)) {
5640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5641 }
5642 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5643 {
5644 arg2 = &temp2;
5645 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5646 }
5647 {
5648 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5649 if (PyErr_Occurred()) SWIG_fail;
5650 }
5651 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5652 return resultobj;
5653 fail:
5654 return NULL;
5655 }
5656
5657
5658 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5659 PyObject *resultobj = 0;
5660 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5661 double arg2 ;
5662 double arg3 ;
5663 void *argp1 = 0 ;
5664 int res1 = 0 ;
5665 double val2 ;
5666 int ecode2 = 0 ;
5667 double val3 ;
5668 int ecode3 = 0 ;
5669 PyObject * obj0 = 0 ;
5670 PyObject * obj1 = 0 ;
5671 PyObject * obj2 = 0 ;
5672 char * kwnames[] = {
5673 (char *) "self",(char *) "x",(char *) "y", NULL
5674 };
5675
5676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) 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_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5680 }
5681 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5682 ecode2 = SWIG_AsVal_double(obj1, &val2);
5683 if (!SWIG_IsOK(ecode2)) {
5684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5685 }
5686 arg2 = static_cast< double >(val2);
5687 ecode3 = SWIG_AsVal_double(obj2, &val3);
5688 if (!SWIG_IsOK(ecode3)) {
5689 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5690 }
5691 arg3 = static_cast< double >(val3);
5692 {
5693 wxRealPoint_Set(arg1,arg2,arg3);
5694 if (PyErr_Occurred()) SWIG_fail;
5695 }
5696 resultobj = SWIG_Py_Void();
5697 return resultobj;
5698 fail:
5699 return NULL;
5700 }
5701
5702
5703 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5704 PyObject *resultobj = 0;
5705 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5706 PyObject *result = 0 ;
5707 void *argp1 = 0 ;
5708 int res1 = 0 ;
5709 PyObject *swig_obj[1] ;
5710
5711 if (!args) SWIG_fail;
5712 swig_obj[0] = args;
5713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5714 if (!SWIG_IsOK(res1)) {
5715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5716 }
5717 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5718 {
5719 result = (PyObject *)wxRealPoint_Get(arg1);
5720 if (PyErr_Occurred()) SWIG_fail;
5721 }
5722 resultobj = result;
5723 return resultobj;
5724 fail:
5725 return NULL;
5726 }
5727
5728
5729 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5730 PyObject *obj;
5731 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5732 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5733 return SWIG_Py_Void();
5734 }
5735
5736 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5737 return SWIG_Python_InitShadowInstance(args);
5738 }
5739
5740 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5741 PyObject *resultobj = 0;
5742 wxPoint *arg1 = (wxPoint *) 0 ;
5743 int arg2 ;
5744 void *argp1 = 0 ;
5745 int res1 = 0 ;
5746 int val2 ;
5747 int ecode2 = 0 ;
5748 PyObject *swig_obj[2] ;
5749
5750 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5752 if (!SWIG_IsOK(res1)) {
5753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5754 }
5755 arg1 = reinterpret_cast< wxPoint * >(argp1);
5756 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5757 if (!SWIG_IsOK(ecode2)) {
5758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5759 }
5760 arg2 = static_cast< int >(val2);
5761 if (arg1) (arg1)->x = arg2;
5762
5763 resultobj = SWIG_Py_Void();
5764 return resultobj;
5765 fail:
5766 return NULL;
5767 }
5768
5769
5770 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5771 PyObject *resultobj = 0;
5772 wxPoint *arg1 = (wxPoint *) 0 ;
5773 int result;
5774 void *argp1 = 0 ;
5775 int res1 = 0 ;
5776 PyObject *swig_obj[1] ;
5777
5778 if (!args) SWIG_fail;
5779 swig_obj[0] = args;
5780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5781 if (!SWIG_IsOK(res1)) {
5782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5783 }
5784 arg1 = reinterpret_cast< wxPoint * >(argp1);
5785 result = (int) ((arg1)->x);
5786 resultobj = SWIG_From_int(static_cast< int >(result));
5787 return resultobj;
5788 fail:
5789 return NULL;
5790 }
5791
5792
5793 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5794 PyObject *resultobj = 0;
5795 wxPoint *arg1 = (wxPoint *) 0 ;
5796 int arg2 ;
5797 void *argp1 = 0 ;
5798 int res1 = 0 ;
5799 int val2 ;
5800 int ecode2 = 0 ;
5801 PyObject *swig_obj[2] ;
5802
5803 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5805 if (!SWIG_IsOK(res1)) {
5806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5807 }
5808 arg1 = reinterpret_cast< wxPoint * >(argp1);
5809 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5810 if (!SWIG_IsOK(ecode2)) {
5811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5812 }
5813 arg2 = static_cast< int >(val2);
5814 if (arg1) (arg1)->y = arg2;
5815
5816 resultobj = SWIG_Py_Void();
5817 return resultobj;
5818 fail:
5819 return NULL;
5820 }
5821
5822
5823 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5824 PyObject *resultobj = 0;
5825 wxPoint *arg1 = (wxPoint *) 0 ;
5826 int result;
5827 void *argp1 = 0 ;
5828 int res1 = 0 ;
5829 PyObject *swig_obj[1] ;
5830
5831 if (!args) SWIG_fail;
5832 swig_obj[0] = args;
5833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5834 if (!SWIG_IsOK(res1)) {
5835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5836 }
5837 arg1 = reinterpret_cast< wxPoint * >(argp1);
5838 result = (int) ((arg1)->y);
5839 resultobj = SWIG_From_int(static_cast< int >(result));
5840 return resultobj;
5841 fail:
5842 return NULL;
5843 }
5844
5845
5846 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5847 PyObject *resultobj = 0;
5848 int arg1 = (int) 0 ;
5849 int arg2 = (int) 0 ;
5850 wxPoint *result = 0 ;
5851 int val1 ;
5852 int ecode1 = 0 ;
5853 int val2 ;
5854 int ecode2 = 0 ;
5855 PyObject * obj0 = 0 ;
5856 PyObject * obj1 = 0 ;
5857 char * kwnames[] = {
5858 (char *) "x",(char *) "y", NULL
5859 };
5860
5861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5862 if (obj0) {
5863 ecode1 = SWIG_AsVal_int(obj0, &val1);
5864 if (!SWIG_IsOK(ecode1)) {
5865 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5866 }
5867 arg1 = static_cast< int >(val1);
5868 }
5869 if (obj1) {
5870 ecode2 = SWIG_AsVal_int(obj1, &val2);
5871 if (!SWIG_IsOK(ecode2)) {
5872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5873 }
5874 arg2 = static_cast< int >(val2);
5875 }
5876 {
5877 result = (wxPoint *)new wxPoint(arg1,arg2);
5878 if (PyErr_Occurred()) SWIG_fail;
5879 }
5880 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5881 return resultobj;
5882 fail:
5883 return NULL;
5884 }
5885
5886
5887 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5888 PyObject *resultobj = 0;
5889 wxPoint *arg1 = (wxPoint *) 0 ;
5890 void *argp1 = 0 ;
5891 int res1 = 0 ;
5892 PyObject *swig_obj[1] ;
5893
5894 if (!args) SWIG_fail;
5895 swig_obj[0] = args;
5896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5897 if (!SWIG_IsOK(res1)) {
5898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5899 }
5900 arg1 = reinterpret_cast< wxPoint * >(argp1);
5901 {
5902 delete arg1;
5903
5904 if (PyErr_Occurred()) SWIG_fail;
5905 }
5906 resultobj = SWIG_Py_Void();
5907 return resultobj;
5908 fail:
5909 return NULL;
5910 }
5911
5912
5913 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5914 PyObject *resultobj = 0;
5915 wxPoint *arg1 = (wxPoint *) 0 ;
5916 PyObject *arg2 = (PyObject *) 0 ;
5917 bool result;
5918 void *argp1 = 0 ;
5919 int res1 = 0 ;
5920 PyObject * obj0 = 0 ;
5921 PyObject * obj1 = 0 ;
5922 char * kwnames[] = {
5923 (char *) "self",(char *) "other", NULL
5924 };
5925
5926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5928 if (!SWIG_IsOK(res1)) {
5929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5930 }
5931 arg1 = reinterpret_cast< wxPoint * >(argp1);
5932 arg2 = obj1;
5933 {
5934 result = (bool)wxPoint___eq__(arg1,arg2);
5935 if (PyErr_Occurred()) SWIG_fail;
5936 }
5937 {
5938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5939 }
5940 return resultobj;
5941 fail:
5942 return NULL;
5943 }
5944
5945
5946 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5947 PyObject *resultobj = 0;
5948 wxPoint *arg1 = (wxPoint *) 0 ;
5949 PyObject *arg2 = (PyObject *) 0 ;
5950 bool result;
5951 void *argp1 = 0 ;
5952 int res1 = 0 ;
5953 PyObject * obj0 = 0 ;
5954 PyObject * obj1 = 0 ;
5955 char * kwnames[] = {
5956 (char *) "self",(char *) "other", NULL
5957 };
5958
5959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5961 if (!SWIG_IsOK(res1)) {
5962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5963 }
5964 arg1 = reinterpret_cast< wxPoint * >(argp1);
5965 arg2 = obj1;
5966 {
5967 result = (bool)wxPoint___ne__(arg1,arg2);
5968 if (PyErr_Occurred()) SWIG_fail;
5969 }
5970 {
5971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5972 }
5973 return resultobj;
5974 fail:
5975 return NULL;
5976 }
5977
5978
5979 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5980 PyObject *resultobj = 0;
5981 wxPoint *arg1 = (wxPoint *) 0 ;
5982 wxPoint *arg2 = 0 ;
5983 wxPoint result;
5984 void *argp1 = 0 ;
5985 int res1 = 0 ;
5986 wxPoint temp2 ;
5987 PyObject * obj0 = 0 ;
5988 PyObject * obj1 = 0 ;
5989 char * kwnames[] = {
5990 (char *) "self",(char *) "pt", NULL
5991 };
5992
5993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5995 if (!SWIG_IsOK(res1)) {
5996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5997 }
5998 arg1 = reinterpret_cast< wxPoint * >(argp1);
5999 {
6000 arg2 = &temp2;
6001 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6002 }
6003 {
6004 result = (arg1)->operator +((wxPoint const &)*arg2);
6005 if (PyErr_Occurred()) SWIG_fail;
6006 }
6007 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6008 return resultobj;
6009 fail:
6010 return NULL;
6011 }
6012
6013
6014 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6015 PyObject *resultobj = 0;
6016 wxPoint *arg1 = (wxPoint *) 0 ;
6017 wxPoint *arg2 = 0 ;
6018 wxPoint result;
6019 void *argp1 = 0 ;
6020 int res1 = 0 ;
6021 wxPoint temp2 ;
6022 PyObject * obj0 = 0 ;
6023 PyObject * obj1 = 0 ;
6024 char * kwnames[] = {
6025 (char *) "self",(char *) "pt", NULL
6026 };
6027
6028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
6029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6030 if (!SWIG_IsOK(res1)) {
6031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6032 }
6033 arg1 = reinterpret_cast< wxPoint * >(argp1);
6034 {
6035 arg2 = &temp2;
6036 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6037 }
6038 {
6039 result = (arg1)->operator -((wxPoint const &)*arg2);
6040 if (PyErr_Occurred()) SWIG_fail;
6041 }
6042 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6043 return resultobj;
6044 fail:
6045 return NULL;
6046 }
6047
6048
6049 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6050 PyObject *resultobj = 0;
6051 wxPoint *arg1 = (wxPoint *) 0 ;
6052 wxPoint *arg2 = 0 ;
6053 wxPoint *result = 0 ;
6054 void *argp1 = 0 ;
6055 int res1 = 0 ;
6056 wxPoint temp2 ;
6057 PyObject * obj0 = 0 ;
6058 PyObject * obj1 = 0 ;
6059 char * kwnames[] = {
6060 (char *) "self",(char *) "pt", NULL
6061 };
6062
6063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
6064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6065 if (!SWIG_IsOK(res1)) {
6066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
6067 }
6068 arg1 = reinterpret_cast< wxPoint * >(argp1);
6069 {
6070 arg2 = &temp2;
6071 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6072 }
6073 {
6074 {
6075 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
6076 result = (wxPoint *) &_result_ref;
6077 }
6078 if (PyErr_Occurred()) SWIG_fail;
6079 }
6080 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6081 return resultobj;
6082 fail:
6083 return NULL;
6084 }
6085
6086
6087 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6088 PyObject *resultobj = 0;
6089 wxPoint *arg1 = (wxPoint *) 0 ;
6090 wxPoint *arg2 = 0 ;
6091 wxPoint *result = 0 ;
6092 void *argp1 = 0 ;
6093 int res1 = 0 ;
6094 wxPoint temp2 ;
6095 PyObject * obj0 = 0 ;
6096 PyObject * obj1 = 0 ;
6097 char * kwnames[] = {
6098 (char *) "self",(char *) "pt", NULL
6099 };
6100
6101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
6102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6103 if (!SWIG_IsOK(res1)) {
6104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6105 }
6106 arg1 = reinterpret_cast< wxPoint * >(argp1);
6107 {
6108 arg2 = &temp2;
6109 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6110 }
6111 {
6112 {
6113 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
6114 result = (wxPoint *) &_result_ref;
6115 }
6116 if (PyErr_Occurred()) SWIG_fail;
6117 }
6118 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6119 return resultobj;
6120 fail:
6121 return NULL;
6122 }
6123
6124
6125 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6126 PyObject *resultobj = 0;
6127 wxPoint *arg1 = (wxPoint *) 0 ;
6128 long arg2 ;
6129 long arg3 ;
6130 void *argp1 = 0 ;
6131 int res1 = 0 ;
6132 long val2 ;
6133 int ecode2 = 0 ;
6134 long val3 ;
6135 int ecode3 = 0 ;
6136 PyObject * obj0 = 0 ;
6137 PyObject * obj1 = 0 ;
6138 PyObject * obj2 = 0 ;
6139 char * kwnames[] = {
6140 (char *) "self",(char *) "x",(char *) "y", NULL
6141 };
6142
6143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6145 if (!SWIG_IsOK(res1)) {
6146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6147 }
6148 arg1 = reinterpret_cast< wxPoint * >(argp1);
6149 ecode2 = SWIG_AsVal_long(obj1, &val2);
6150 if (!SWIG_IsOK(ecode2)) {
6151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6152 }
6153 arg2 = static_cast< long >(val2);
6154 ecode3 = SWIG_AsVal_long(obj2, &val3);
6155 if (!SWIG_IsOK(ecode3)) {
6156 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6157 }
6158 arg3 = static_cast< long >(val3);
6159 {
6160 wxPoint_Set(arg1,arg2,arg3);
6161 if (PyErr_Occurred()) SWIG_fail;
6162 }
6163 resultobj = SWIG_Py_Void();
6164 return resultobj;
6165 fail:
6166 return NULL;
6167 }
6168
6169
6170 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6171 PyObject *resultobj = 0;
6172 wxPoint *arg1 = (wxPoint *) 0 ;
6173 PyObject *result = 0 ;
6174 void *argp1 = 0 ;
6175 int res1 = 0 ;
6176 PyObject *swig_obj[1] ;
6177
6178 if (!args) SWIG_fail;
6179 swig_obj[0] = args;
6180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6181 if (!SWIG_IsOK(res1)) {
6182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6183 }
6184 arg1 = reinterpret_cast< wxPoint * >(argp1);
6185 {
6186 result = (PyObject *)wxPoint_Get(arg1);
6187 if (PyErr_Occurred()) SWIG_fail;
6188 }
6189 resultobj = result;
6190 return resultobj;
6191 fail:
6192 return NULL;
6193 }
6194
6195
6196 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6197 PyObject *obj;
6198 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6199 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6200 return SWIG_Py_Void();
6201 }
6202
6203 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6204 return SWIG_Python_InitShadowInstance(args);
6205 }
6206
6207 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6208 PyObject *resultobj = 0;
6209 int arg1 = (int) 0 ;
6210 int arg2 = (int) 0 ;
6211 int arg3 = (int) 0 ;
6212 int arg4 = (int) 0 ;
6213 wxRect *result = 0 ;
6214 int val1 ;
6215 int ecode1 = 0 ;
6216 int val2 ;
6217 int ecode2 = 0 ;
6218 int val3 ;
6219 int ecode3 = 0 ;
6220 int val4 ;
6221 int ecode4 = 0 ;
6222 PyObject * obj0 = 0 ;
6223 PyObject * obj1 = 0 ;
6224 PyObject * obj2 = 0 ;
6225 PyObject * obj3 = 0 ;
6226 char * kwnames[] = {
6227 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6228 };
6229
6230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6231 if (obj0) {
6232 ecode1 = SWIG_AsVal_int(obj0, &val1);
6233 if (!SWIG_IsOK(ecode1)) {
6234 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6235 }
6236 arg1 = static_cast< int >(val1);
6237 }
6238 if (obj1) {
6239 ecode2 = SWIG_AsVal_int(obj1, &val2);
6240 if (!SWIG_IsOK(ecode2)) {
6241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6242 }
6243 arg2 = static_cast< int >(val2);
6244 }
6245 if (obj2) {
6246 ecode3 = SWIG_AsVal_int(obj2, &val3);
6247 if (!SWIG_IsOK(ecode3)) {
6248 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6249 }
6250 arg3 = static_cast< int >(val3);
6251 }
6252 if (obj3) {
6253 ecode4 = SWIG_AsVal_int(obj3, &val4);
6254 if (!SWIG_IsOK(ecode4)) {
6255 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6256 }
6257 arg4 = static_cast< int >(val4);
6258 }
6259 {
6260 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6261 if (PyErr_Occurred()) SWIG_fail;
6262 }
6263 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6264 return resultobj;
6265 fail:
6266 return NULL;
6267 }
6268
6269
6270 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6271 PyObject *resultobj = 0;
6272 wxPoint *arg1 = 0 ;
6273 wxPoint *arg2 = 0 ;
6274 wxRect *result = 0 ;
6275 wxPoint temp1 ;
6276 wxPoint temp2 ;
6277 PyObject * obj0 = 0 ;
6278 PyObject * obj1 = 0 ;
6279 char * kwnames[] = {
6280 (char *) "topLeft",(char *) "bottomRight", NULL
6281 };
6282
6283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6284 {
6285 arg1 = &temp1;
6286 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6287 }
6288 {
6289 arg2 = &temp2;
6290 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6291 }
6292 {
6293 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6294 if (PyErr_Occurred()) SWIG_fail;
6295 }
6296 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6297 return resultobj;
6298 fail:
6299 return NULL;
6300 }
6301
6302
6303 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6304 PyObject *resultobj = 0;
6305 wxPoint *arg1 = 0 ;
6306 wxSize *arg2 = 0 ;
6307 wxRect *result = 0 ;
6308 wxPoint temp1 ;
6309 wxSize temp2 ;
6310 PyObject * obj0 = 0 ;
6311 PyObject * obj1 = 0 ;
6312 char * kwnames[] = {
6313 (char *) "pos",(char *) "size", NULL
6314 };
6315
6316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6317 {
6318 arg1 = &temp1;
6319 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6320 }
6321 {
6322 arg2 = &temp2;
6323 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6324 }
6325 {
6326 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6327 if (PyErr_Occurred()) SWIG_fail;
6328 }
6329 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6330 return resultobj;
6331 fail:
6332 return NULL;
6333 }
6334
6335
6336 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6337 PyObject *resultobj = 0;
6338 wxSize *arg1 = 0 ;
6339 wxRect *result = 0 ;
6340 wxSize temp1 ;
6341 PyObject * obj0 = 0 ;
6342 char * kwnames[] = {
6343 (char *) "size", NULL
6344 };
6345
6346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6347 {
6348 arg1 = &temp1;
6349 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6350 }
6351 {
6352 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6353 if (PyErr_Occurred()) SWIG_fail;
6354 }
6355 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6356 return resultobj;
6357 fail:
6358 return NULL;
6359 }
6360
6361
6362 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6363 PyObject *resultobj = 0;
6364 wxRect *arg1 = (wxRect *) 0 ;
6365 void *argp1 = 0 ;
6366 int res1 = 0 ;
6367 PyObject *swig_obj[1] ;
6368
6369 if (!args) SWIG_fail;
6370 swig_obj[0] = args;
6371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6372 if (!SWIG_IsOK(res1)) {
6373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6374 }
6375 arg1 = reinterpret_cast< wxRect * >(argp1);
6376 {
6377 delete arg1;
6378
6379 if (PyErr_Occurred()) SWIG_fail;
6380 }
6381 resultobj = SWIG_Py_Void();
6382 return resultobj;
6383 fail:
6384 return NULL;
6385 }
6386
6387
6388 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6389 PyObject *resultobj = 0;
6390 wxRect *arg1 = (wxRect *) 0 ;
6391 int result;
6392 void *argp1 = 0 ;
6393 int res1 = 0 ;
6394 PyObject *swig_obj[1] ;
6395
6396 if (!args) SWIG_fail;
6397 swig_obj[0] = args;
6398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6399 if (!SWIG_IsOK(res1)) {
6400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6401 }
6402 arg1 = reinterpret_cast< wxRect * >(argp1);
6403 {
6404 result = (int)((wxRect const *)arg1)->GetX();
6405 if (PyErr_Occurred()) SWIG_fail;
6406 }
6407 resultobj = SWIG_From_int(static_cast< int >(result));
6408 return resultobj;
6409 fail:
6410 return NULL;
6411 }
6412
6413
6414 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6415 PyObject *resultobj = 0;
6416 wxRect *arg1 = (wxRect *) 0 ;
6417 int arg2 ;
6418 void *argp1 = 0 ;
6419 int res1 = 0 ;
6420 int val2 ;
6421 int ecode2 = 0 ;
6422 PyObject * obj0 = 0 ;
6423 PyObject * obj1 = 0 ;
6424 char * kwnames[] = {
6425 (char *) "self",(char *) "x", NULL
6426 };
6427
6428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6430 if (!SWIG_IsOK(res1)) {
6431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6432 }
6433 arg1 = reinterpret_cast< wxRect * >(argp1);
6434 ecode2 = SWIG_AsVal_int(obj1, &val2);
6435 if (!SWIG_IsOK(ecode2)) {
6436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6437 }
6438 arg2 = static_cast< int >(val2);
6439 {
6440 (arg1)->SetX(arg2);
6441 if (PyErr_Occurred()) SWIG_fail;
6442 }
6443 resultobj = SWIG_Py_Void();
6444 return resultobj;
6445 fail:
6446 return NULL;
6447 }
6448
6449
6450 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6451 PyObject *resultobj = 0;
6452 wxRect *arg1 = (wxRect *) 0 ;
6453 int result;
6454 void *argp1 = 0 ;
6455 int res1 = 0 ;
6456 PyObject *swig_obj[1] ;
6457
6458 if (!args) SWIG_fail;
6459 swig_obj[0] = args;
6460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6461 if (!SWIG_IsOK(res1)) {
6462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6463 }
6464 arg1 = reinterpret_cast< wxRect * >(argp1);
6465 {
6466 result = (int)(arg1)->GetY();
6467 if (PyErr_Occurred()) SWIG_fail;
6468 }
6469 resultobj = SWIG_From_int(static_cast< int >(result));
6470 return resultobj;
6471 fail:
6472 return NULL;
6473 }
6474
6475
6476 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6477 PyObject *resultobj = 0;
6478 wxRect *arg1 = (wxRect *) 0 ;
6479 int arg2 ;
6480 void *argp1 = 0 ;
6481 int res1 = 0 ;
6482 int val2 ;
6483 int ecode2 = 0 ;
6484 PyObject * obj0 = 0 ;
6485 PyObject * obj1 = 0 ;
6486 char * kwnames[] = {
6487 (char *) "self",(char *) "y", NULL
6488 };
6489
6490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6492 if (!SWIG_IsOK(res1)) {
6493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6494 }
6495 arg1 = reinterpret_cast< wxRect * >(argp1);
6496 ecode2 = SWIG_AsVal_int(obj1, &val2);
6497 if (!SWIG_IsOK(ecode2)) {
6498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6499 }
6500 arg2 = static_cast< int >(val2);
6501 {
6502 (arg1)->SetY(arg2);
6503 if (PyErr_Occurred()) SWIG_fail;
6504 }
6505 resultobj = SWIG_Py_Void();
6506 return resultobj;
6507 fail:
6508 return NULL;
6509 }
6510
6511
6512 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6513 PyObject *resultobj = 0;
6514 wxRect *arg1 = (wxRect *) 0 ;
6515 int result;
6516 void *argp1 = 0 ;
6517 int res1 = 0 ;
6518 PyObject *swig_obj[1] ;
6519
6520 if (!args) SWIG_fail;
6521 swig_obj[0] = args;
6522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6523 if (!SWIG_IsOK(res1)) {
6524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6525 }
6526 arg1 = reinterpret_cast< wxRect * >(argp1);
6527 {
6528 result = (int)((wxRect const *)arg1)->GetWidth();
6529 if (PyErr_Occurred()) SWIG_fail;
6530 }
6531 resultobj = SWIG_From_int(static_cast< int >(result));
6532 return resultobj;
6533 fail:
6534 return NULL;
6535 }
6536
6537
6538 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6539 PyObject *resultobj = 0;
6540 wxRect *arg1 = (wxRect *) 0 ;
6541 int arg2 ;
6542 void *argp1 = 0 ;
6543 int res1 = 0 ;
6544 int val2 ;
6545 int ecode2 = 0 ;
6546 PyObject * obj0 = 0 ;
6547 PyObject * obj1 = 0 ;
6548 char * kwnames[] = {
6549 (char *) "self",(char *) "w", NULL
6550 };
6551
6552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6554 if (!SWIG_IsOK(res1)) {
6555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6556 }
6557 arg1 = reinterpret_cast< wxRect * >(argp1);
6558 ecode2 = SWIG_AsVal_int(obj1, &val2);
6559 if (!SWIG_IsOK(ecode2)) {
6560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6561 }
6562 arg2 = static_cast< int >(val2);
6563 {
6564 (arg1)->SetWidth(arg2);
6565 if (PyErr_Occurred()) SWIG_fail;
6566 }
6567 resultobj = SWIG_Py_Void();
6568 return resultobj;
6569 fail:
6570 return NULL;
6571 }
6572
6573
6574 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6575 PyObject *resultobj = 0;
6576 wxRect *arg1 = (wxRect *) 0 ;
6577 int result;
6578 void *argp1 = 0 ;
6579 int res1 = 0 ;
6580 PyObject *swig_obj[1] ;
6581
6582 if (!args) SWIG_fail;
6583 swig_obj[0] = args;
6584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6585 if (!SWIG_IsOK(res1)) {
6586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6587 }
6588 arg1 = reinterpret_cast< wxRect * >(argp1);
6589 {
6590 result = (int)((wxRect const *)arg1)->GetHeight();
6591 if (PyErr_Occurred()) SWIG_fail;
6592 }
6593 resultobj = SWIG_From_int(static_cast< int >(result));
6594 return resultobj;
6595 fail:
6596 return NULL;
6597 }
6598
6599
6600 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6601 PyObject *resultobj = 0;
6602 wxRect *arg1 = (wxRect *) 0 ;
6603 int arg2 ;
6604 void *argp1 = 0 ;
6605 int res1 = 0 ;
6606 int val2 ;
6607 int ecode2 = 0 ;
6608 PyObject * obj0 = 0 ;
6609 PyObject * obj1 = 0 ;
6610 char * kwnames[] = {
6611 (char *) "self",(char *) "h", NULL
6612 };
6613
6614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6616 if (!SWIG_IsOK(res1)) {
6617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6618 }
6619 arg1 = reinterpret_cast< wxRect * >(argp1);
6620 ecode2 = SWIG_AsVal_int(obj1, &val2);
6621 if (!SWIG_IsOK(ecode2)) {
6622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6623 }
6624 arg2 = static_cast< int >(val2);
6625 {
6626 (arg1)->SetHeight(arg2);
6627 if (PyErr_Occurred()) SWIG_fail;
6628 }
6629 resultobj = SWIG_Py_Void();
6630 return resultobj;
6631 fail:
6632 return NULL;
6633 }
6634
6635
6636 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6637 PyObject *resultobj = 0;
6638 wxRect *arg1 = (wxRect *) 0 ;
6639 wxPoint result;
6640 void *argp1 = 0 ;
6641 int res1 = 0 ;
6642 PyObject *swig_obj[1] ;
6643
6644 if (!args) SWIG_fail;
6645 swig_obj[0] = args;
6646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6647 if (!SWIG_IsOK(res1)) {
6648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6649 }
6650 arg1 = reinterpret_cast< wxRect * >(argp1);
6651 {
6652 result = ((wxRect const *)arg1)->GetPosition();
6653 if (PyErr_Occurred()) SWIG_fail;
6654 }
6655 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6656 return resultobj;
6657 fail:
6658 return NULL;
6659 }
6660
6661
6662 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6663 PyObject *resultobj = 0;
6664 wxRect *arg1 = (wxRect *) 0 ;
6665 wxPoint *arg2 = 0 ;
6666 void *argp1 = 0 ;
6667 int res1 = 0 ;
6668 wxPoint temp2 ;
6669 PyObject * obj0 = 0 ;
6670 PyObject * obj1 = 0 ;
6671 char * kwnames[] = {
6672 (char *) "self",(char *) "p", NULL
6673 };
6674
6675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6677 if (!SWIG_IsOK(res1)) {
6678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6679 }
6680 arg1 = reinterpret_cast< wxRect * >(argp1);
6681 {
6682 arg2 = &temp2;
6683 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6684 }
6685 {
6686 (arg1)->SetPosition((wxPoint const &)*arg2);
6687 if (PyErr_Occurred()) SWIG_fail;
6688 }
6689 resultobj = SWIG_Py_Void();
6690 return resultobj;
6691 fail:
6692 return NULL;
6693 }
6694
6695
6696 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6697 PyObject *resultobj = 0;
6698 wxRect *arg1 = (wxRect *) 0 ;
6699 wxSize result;
6700 void *argp1 = 0 ;
6701 int res1 = 0 ;
6702 PyObject *swig_obj[1] ;
6703
6704 if (!args) SWIG_fail;
6705 swig_obj[0] = args;
6706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6707 if (!SWIG_IsOK(res1)) {
6708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6709 }
6710 arg1 = reinterpret_cast< wxRect * >(argp1);
6711 {
6712 result = ((wxRect const *)arg1)->GetSize();
6713 if (PyErr_Occurred()) SWIG_fail;
6714 }
6715 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6716 return resultobj;
6717 fail:
6718 return NULL;
6719 }
6720
6721
6722 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6723 PyObject *resultobj = 0;
6724 wxRect *arg1 = (wxRect *) 0 ;
6725 wxSize *arg2 = 0 ;
6726 void *argp1 = 0 ;
6727 int res1 = 0 ;
6728 wxSize temp2 ;
6729 PyObject * obj0 = 0 ;
6730 PyObject * obj1 = 0 ;
6731 char * kwnames[] = {
6732 (char *) "self",(char *) "s", NULL
6733 };
6734
6735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6737 if (!SWIG_IsOK(res1)) {
6738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6739 }
6740 arg1 = reinterpret_cast< wxRect * >(argp1);
6741 {
6742 arg2 = &temp2;
6743 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6744 }
6745 {
6746 (arg1)->SetSize((wxSize const &)*arg2);
6747 if (PyErr_Occurred()) SWIG_fail;
6748 }
6749 resultobj = SWIG_Py_Void();
6750 return resultobj;
6751 fail:
6752 return NULL;
6753 }
6754
6755
6756 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6757 PyObject *resultobj = 0;
6758 wxRect *arg1 = (wxRect *) 0 ;
6759 bool result;
6760 void *argp1 = 0 ;
6761 int res1 = 0 ;
6762 PyObject *swig_obj[1] ;
6763
6764 if (!args) SWIG_fail;
6765 swig_obj[0] = args;
6766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6767 if (!SWIG_IsOK(res1)) {
6768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6769 }
6770 arg1 = reinterpret_cast< wxRect * >(argp1);
6771 {
6772 result = (bool)((wxRect const *)arg1)->IsEmpty();
6773 if (PyErr_Occurred()) SWIG_fail;
6774 }
6775 {
6776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6777 }
6778 return resultobj;
6779 fail:
6780 return NULL;
6781 }
6782
6783
6784 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6785 PyObject *resultobj = 0;
6786 wxRect *arg1 = (wxRect *) 0 ;
6787 wxPoint result;
6788 void *argp1 = 0 ;
6789 int res1 = 0 ;
6790 PyObject *swig_obj[1] ;
6791
6792 if (!args) SWIG_fail;
6793 swig_obj[0] = args;
6794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6795 if (!SWIG_IsOK(res1)) {
6796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6797 }
6798 arg1 = reinterpret_cast< wxRect * >(argp1);
6799 {
6800 result = ((wxRect const *)arg1)->GetTopLeft();
6801 if (PyErr_Occurred()) SWIG_fail;
6802 }
6803 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6804 return resultobj;
6805 fail:
6806 return NULL;
6807 }
6808
6809
6810 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6811 PyObject *resultobj = 0;
6812 wxRect *arg1 = (wxRect *) 0 ;
6813 wxPoint *arg2 = 0 ;
6814 void *argp1 = 0 ;
6815 int res1 = 0 ;
6816 wxPoint temp2 ;
6817 PyObject * obj0 = 0 ;
6818 PyObject * obj1 = 0 ;
6819 char * kwnames[] = {
6820 (char *) "self",(char *) "p", NULL
6821 };
6822
6823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6825 if (!SWIG_IsOK(res1)) {
6826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6827 }
6828 arg1 = reinterpret_cast< wxRect * >(argp1);
6829 {
6830 arg2 = &temp2;
6831 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6832 }
6833 {
6834 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6835 if (PyErr_Occurred()) SWIG_fail;
6836 }
6837 resultobj = SWIG_Py_Void();
6838 return resultobj;
6839 fail:
6840 return NULL;
6841 }
6842
6843
6844 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6845 PyObject *resultobj = 0;
6846 wxRect *arg1 = (wxRect *) 0 ;
6847 wxPoint result;
6848 void *argp1 = 0 ;
6849 int res1 = 0 ;
6850 PyObject *swig_obj[1] ;
6851
6852 if (!args) SWIG_fail;
6853 swig_obj[0] = args;
6854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6855 if (!SWIG_IsOK(res1)) {
6856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6857 }
6858 arg1 = reinterpret_cast< wxRect * >(argp1);
6859 {
6860 result = ((wxRect const *)arg1)->GetBottomRight();
6861 if (PyErr_Occurred()) SWIG_fail;
6862 }
6863 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6864 return resultobj;
6865 fail:
6866 return NULL;
6867 }
6868
6869
6870 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6871 PyObject *resultobj = 0;
6872 wxRect *arg1 = (wxRect *) 0 ;
6873 wxPoint *arg2 = 0 ;
6874 void *argp1 = 0 ;
6875 int res1 = 0 ;
6876 wxPoint temp2 ;
6877 PyObject * obj0 = 0 ;
6878 PyObject * obj1 = 0 ;
6879 char * kwnames[] = {
6880 (char *) "self",(char *) "p", NULL
6881 };
6882
6883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6885 if (!SWIG_IsOK(res1)) {
6886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6887 }
6888 arg1 = reinterpret_cast< wxRect * >(argp1);
6889 {
6890 arg2 = &temp2;
6891 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6892 }
6893 {
6894 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6895 if (PyErr_Occurred()) SWIG_fail;
6896 }
6897 resultobj = SWIG_Py_Void();
6898 return resultobj;
6899 fail:
6900 return NULL;
6901 }
6902
6903
6904 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6905 PyObject *resultobj = 0;
6906 wxRect *arg1 = (wxRect *) 0 ;
6907 wxPoint result;
6908 void *argp1 = 0 ;
6909 int res1 = 0 ;
6910 PyObject *swig_obj[1] ;
6911
6912 if (!args) SWIG_fail;
6913 swig_obj[0] = args;
6914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6915 if (!SWIG_IsOK(res1)) {
6916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6917 }
6918 arg1 = reinterpret_cast< wxRect * >(argp1);
6919 {
6920 result = ((wxRect const *)arg1)->GetTopRight();
6921 if (PyErr_Occurred()) SWIG_fail;
6922 }
6923 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6924 return resultobj;
6925 fail:
6926 return NULL;
6927 }
6928
6929
6930 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6931 PyObject *resultobj = 0;
6932 wxRect *arg1 = (wxRect *) 0 ;
6933 wxPoint *arg2 = 0 ;
6934 void *argp1 = 0 ;
6935 int res1 = 0 ;
6936 wxPoint temp2 ;
6937 PyObject * obj0 = 0 ;
6938 PyObject * obj1 = 0 ;
6939 char * kwnames[] = {
6940 (char *) "self",(char *) "p", NULL
6941 };
6942
6943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
6944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6945 if (!SWIG_IsOK(res1)) {
6946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
6947 }
6948 arg1 = reinterpret_cast< wxRect * >(argp1);
6949 {
6950 arg2 = &temp2;
6951 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6952 }
6953 {
6954 (arg1)->SetTopRight((wxPoint const &)*arg2);
6955 if (PyErr_Occurred()) SWIG_fail;
6956 }
6957 resultobj = SWIG_Py_Void();
6958 return resultobj;
6959 fail:
6960 return NULL;
6961 }
6962
6963
6964 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6965 PyObject *resultobj = 0;
6966 wxRect *arg1 = (wxRect *) 0 ;
6967 wxPoint result;
6968 void *argp1 = 0 ;
6969 int res1 = 0 ;
6970 PyObject *swig_obj[1] ;
6971
6972 if (!args) SWIG_fail;
6973 swig_obj[0] = args;
6974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6975 if (!SWIG_IsOK(res1)) {
6976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6977 }
6978 arg1 = reinterpret_cast< wxRect * >(argp1);
6979 {
6980 result = ((wxRect const *)arg1)->GetBottomLeft();
6981 if (PyErr_Occurred()) SWIG_fail;
6982 }
6983 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6984 return resultobj;
6985 fail:
6986 return NULL;
6987 }
6988
6989
6990 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6991 PyObject *resultobj = 0;
6992 wxRect *arg1 = (wxRect *) 0 ;
6993 wxPoint *arg2 = 0 ;
6994 void *argp1 = 0 ;
6995 int res1 = 0 ;
6996 wxPoint temp2 ;
6997 PyObject * obj0 = 0 ;
6998 PyObject * obj1 = 0 ;
6999 char * kwnames[] = {
7000 (char *) "self",(char *) "p", NULL
7001 };
7002
7003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7005 if (!SWIG_IsOK(res1)) {
7006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7007 }
7008 arg1 = reinterpret_cast< wxRect * >(argp1);
7009 {
7010 arg2 = &temp2;
7011 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7012 }
7013 {
7014 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
7015 if (PyErr_Occurred()) SWIG_fail;
7016 }
7017 resultobj = SWIG_Py_Void();
7018 return resultobj;
7019 fail:
7020 return NULL;
7021 }
7022
7023
7024 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7025 PyObject *resultobj = 0;
7026 wxRect *arg1 = (wxRect *) 0 ;
7027 int result;
7028 void *argp1 = 0 ;
7029 int res1 = 0 ;
7030 PyObject *swig_obj[1] ;
7031
7032 if (!args) SWIG_fail;
7033 swig_obj[0] = args;
7034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7035 if (!SWIG_IsOK(res1)) {
7036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7037 }
7038 arg1 = reinterpret_cast< wxRect * >(argp1);
7039 {
7040 result = (int)((wxRect const *)arg1)->GetLeft();
7041 if (PyErr_Occurred()) SWIG_fail;
7042 }
7043 resultobj = SWIG_From_int(static_cast< int >(result));
7044 return resultobj;
7045 fail:
7046 return NULL;
7047 }
7048
7049
7050 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7051 PyObject *resultobj = 0;
7052 wxRect *arg1 = (wxRect *) 0 ;
7053 int result;
7054 void *argp1 = 0 ;
7055 int res1 = 0 ;
7056 PyObject *swig_obj[1] ;
7057
7058 if (!args) SWIG_fail;
7059 swig_obj[0] = args;
7060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7061 if (!SWIG_IsOK(res1)) {
7062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
7063 }
7064 arg1 = reinterpret_cast< wxRect * >(argp1);
7065 {
7066 result = (int)((wxRect const *)arg1)->GetTop();
7067 if (PyErr_Occurred()) SWIG_fail;
7068 }
7069 resultobj = SWIG_From_int(static_cast< int >(result));
7070 return resultobj;
7071 fail:
7072 return NULL;
7073 }
7074
7075
7076 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7077 PyObject *resultobj = 0;
7078 wxRect *arg1 = (wxRect *) 0 ;
7079 int result;
7080 void *argp1 = 0 ;
7081 int res1 = 0 ;
7082 PyObject *swig_obj[1] ;
7083
7084 if (!args) SWIG_fail;
7085 swig_obj[0] = args;
7086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7087 if (!SWIG_IsOK(res1)) {
7088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7089 }
7090 arg1 = reinterpret_cast< wxRect * >(argp1);
7091 {
7092 result = (int)((wxRect const *)arg1)->GetBottom();
7093 if (PyErr_Occurred()) SWIG_fail;
7094 }
7095 resultobj = SWIG_From_int(static_cast< int >(result));
7096 return resultobj;
7097 fail:
7098 return NULL;
7099 }
7100
7101
7102 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7103 PyObject *resultobj = 0;
7104 wxRect *arg1 = (wxRect *) 0 ;
7105 int result;
7106 void *argp1 = 0 ;
7107 int res1 = 0 ;
7108 PyObject *swig_obj[1] ;
7109
7110 if (!args) SWIG_fail;
7111 swig_obj[0] = args;
7112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7113 if (!SWIG_IsOK(res1)) {
7114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7115 }
7116 arg1 = reinterpret_cast< wxRect * >(argp1);
7117 {
7118 result = (int)((wxRect const *)arg1)->GetRight();
7119 if (PyErr_Occurred()) SWIG_fail;
7120 }
7121 resultobj = SWIG_From_int(static_cast< int >(result));
7122 return resultobj;
7123 fail:
7124 return NULL;
7125 }
7126
7127
7128 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7129 PyObject *resultobj = 0;
7130 wxRect *arg1 = (wxRect *) 0 ;
7131 int arg2 ;
7132 void *argp1 = 0 ;
7133 int res1 = 0 ;
7134 int val2 ;
7135 int ecode2 = 0 ;
7136 PyObject * obj0 = 0 ;
7137 PyObject * obj1 = 0 ;
7138 char * kwnames[] = {
7139 (char *) "self",(char *) "left", NULL
7140 };
7141
7142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7144 if (!SWIG_IsOK(res1)) {
7145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7146 }
7147 arg1 = reinterpret_cast< wxRect * >(argp1);
7148 ecode2 = SWIG_AsVal_int(obj1, &val2);
7149 if (!SWIG_IsOK(ecode2)) {
7150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
7151 }
7152 arg2 = static_cast< int >(val2);
7153 {
7154 (arg1)->SetLeft(arg2);
7155 if (PyErr_Occurred()) SWIG_fail;
7156 }
7157 resultobj = SWIG_Py_Void();
7158 return resultobj;
7159 fail:
7160 return NULL;
7161 }
7162
7163
7164 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7165 PyObject *resultobj = 0;
7166 wxRect *arg1 = (wxRect *) 0 ;
7167 int arg2 ;
7168 void *argp1 = 0 ;
7169 int res1 = 0 ;
7170 int val2 ;
7171 int ecode2 = 0 ;
7172 PyObject * obj0 = 0 ;
7173 PyObject * obj1 = 0 ;
7174 char * kwnames[] = {
7175 (char *) "self",(char *) "right", NULL
7176 };
7177
7178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
7179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7180 if (!SWIG_IsOK(res1)) {
7181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7182 }
7183 arg1 = reinterpret_cast< wxRect * >(argp1);
7184 ecode2 = SWIG_AsVal_int(obj1, &val2);
7185 if (!SWIG_IsOK(ecode2)) {
7186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7187 }
7188 arg2 = static_cast< int >(val2);
7189 {
7190 (arg1)->SetRight(arg2);
7191 if (PyErr_Occurred()) SWIG_fail;
7192 }
7193 resultobj = SWIG_Py_Void();
7194 return resultobj;
7195 fail:
7196 return NULL;
7197 }
7198
7199
7200 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7201 PyObject *resultobj = 0;
7202 wxRect *arg1 = (wxRect *) 0 ;
7203 int arg2 ;
7204 void *argp1 = 0 ;
7205 int res1 = 0 ;
7206 int val2 ;
7207 int ecode2 = 0 ;
7208 PyObject * obj0 = 0 ;
7209 PyObject * obj1 = 0 ;
7210 char * kwnames[] = {
7211 (char *) "self",(char *) "top", NULL
7212 };
7213
7214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7216 if (!SWIG_IsOK(res1)) {
7217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7218 }
7219 arg1 = reinterpret_cast< wxRect * >(argp1);
7220 ecode2 = SWIG_AsVal_int(obj1, &val2);
7221 if (!SWIG_IsOK(ecode2)) {
7222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7223 }
7224 arg2 = static_cast< int >(val2);
7225 {
7226 (arg1)->SetTop(arg2);
7227 if (PyErr_Occurred()) SWIG_fail;
7228 }
7229 resultobj = SWIG_Py_Void();
7230 return resultobj;
7231 fail:
7232 return NULL;
7233 }
7234
7235
7236 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7237 PyObject *resultobj = 0;
7238 wxRect *arg1 = (wxRect *) 0 ;
7239 int arg2 ;
7240 void *argp1 = 0 ;
7241 int res1 = 0 ;
7242 int val2 ;
7243 int ecode2 = 0 ;
7244 PyObject * obj0 = 0 ;
7245 PyObject * obj1 = 0 ;
7246 char * kwnames[] = {
7247 (char *) "self",(char *) "bottom", NULL
7248 };
7249
7250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7252 if (!SWIG_IsOK(res1)) {
7253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7254 }
7255 arg1 = reinterpret_cast< wxRect * >(argp1);
7256 ecode2 = SWIG_AsVal_int(obj1, &val2);
7257 if (!SWIG_IsOK(ecode2)) {
7258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7259 }
7260 arg2 = static_cast< int >(val2);
7261 {
7262 (arg1)->SetBottom(arg2);
7263 if (PyErr_Occurred()) SWIG_fail;
7264 }
7265 resultobj = SWIG_Py_Void();
7266 return resultobj;
7267 fail:
7268 return NULL;
7269 }
7270
7271
7272 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7273 PyObject *resultobj = 0;
7274 wxRect *arg1 = (wxRect *) 0 ;
7275 int arg2 ;
7276 int arg3 ;
7277 wxRect *result = 0 ;
7278 void *argp1 = 0 ;
7279 int res1 = 0 ;
7280 int val2 ;
7281 int ecode2 = 0 ;
7282 int val3 ;
7283 int ecode3 = 0 ;
7284 PyObject * obj0 = 0 ;
7285 PyObject * obj1 = 0 ;
7286 PyObject * obj2 = 0 ;
7287 char * kwnames[] = {
7288 (char *) "self",(char *) "dx",(char *) "dy", NULL
7289 };
7290
7291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7293 if (!SWIG_IsOK(res1)) {
7294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7295 }
7296 arg1 = reinterpret_cast< wxRect * >(argp1);
7297 ecode2 = SWIG_AsVal_int(obj1, &val2);
7298 if (!SWIG_IsOK(ecode2)) {
7299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7300 }
7301 arg2 = static_cast< int >(val2);
7302 ecode3 = SWIG_AsVal_int(obj2, &val3);
7303 if (!SWIG_IsOK(ecode3)) {
7304 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7305 }
7306 arg3 = static_cast< int >(val3);
7307 {
7308 {
7309 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7310 result = (wxRect *) &_result_ref;
7311 }
7312 if (PyErr_Occurred()) SWIG_fail;
7313 }
7314 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7315 return resultobj;
7316 fail:
7317 return NULL;
7318 }
7319
7320
7321 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7322 PyObject *resultobj = 0;
7323 wxRect *arg1 = (wxRect *) 0 ;
7324 int arg2 ;
7325 int arg3 ;
7326 wxRect *result = 0 ;
7327 void *argp1 = 0 ;
7328 int res1 = 0 ;
7329 int val2 ;
7330 int ecode2 = 0 ;
7331 int val3 ;
7332 int ecode3 = 0 ;
7333 PyObject * obj0 = 0 ;
7334 PyObject * obj1 = 0 ;
7335 PyObject * obj2 = 0 ;
7336 char * kwnames[] = {
7337 (char *) "self",(char *) "dx",(char *) "dy", NULL
7338 };
7339
7340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7342 if (!SWIG_IsOK(res1)) {
7343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7344 }
7345 arg1 = reinterpret_cast< wxRect * >(argp1);
7346 ecode2 = SWIG_AsVal_int(obj1, &val2);
7347 if (!SWIG_IsOK(ecode2)) {
7348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7349 }
7350 arg2 = static_cast< int >(val2);
7351 ecode3 = SWIG_AsVal_int(obj2, &val3);
7352 if (!SWIG_IsOK(ecode3)) {
7353 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7354 }
7355 arg3 = static_cast< int >(val3);
7356 {
7357 {
7358 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7359 result = (wxRect *) &_result_ref;
7360 }
7361 if (PyErr_Occurred()) SWIG_fail;
7362 }
7363 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7364 return resultobj;
7365 fail:
7366 return NULL;
7367 }
7368
7369
7370 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7371 PyObject *resultobj = 0;
7372 wxRect *arg1 = (wxRect *) 0 ;
7373 int arg2 ;
7374 int arg3 ;
7375 void *argp1 = 0 ;
7376 int res1 = 0 ;
7377 int val2 ;
7378 int ecode2 = 0 ;
7379 int val3 ;
7380 int ecode3 = 0 ;
7381 PyObject * obj0 = 0 ;
7382 PyObject * obj1 = 0 ;
7383 PyObject * obj2 = 0 ;
7384 char * kwnames[] = {
7385 (char *) "self",(char *) "dx",(char *) "dy", NULL
7386 };
7387
7388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7390 if (!SWIG_IsOK(res1)) {
7391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7392 }
7393 arg1 = reinterpret_cast< wxRect * >(argp1);
7394 ecode2 = SWIG_AsVal_int(obj1, &val2);
7395 if (!SWIG_IsOK(ecode2)) {
7396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7397 }
7398 arg2 = static_cast< int >(val2);
7399 ecode3 = SWIG_AsVal_int(obj2, &val3);
7400 if (!SWIG_IsOK(ecode3)) {
7401 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7402 }
7403 arg3 = static_cast< int >(val3);
7404 {
7405 (arg1)->Offset(arg2,arg3);
7406 if (PyErr_Occurred()) SWIG_fail;
7407 }
7408 resultobj = SWIG_Py_Void();
7409 return resultobj;
7410 fail:
7411 return NULL;
7412 }
7413
7414
7415 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7416 PyObject *resultobj = 0;
7417 wxRect *arg1 = (wxRect *) 0 ;
7418 wxPoint *arg2 = 0 ;
7419 void *argp1 = 0 ;
7420 int res1 = 0 ;
7421 wxPoint temp2 ;
7422 PyObject * obj0 = 0 ;
7423 PyObject * obj1 = 0 ;
7424 char * kwnames[] = {
7425 (char *) "self",(char *) "pt", NULL
7426 };
7427
7428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7430 if (!SWIG_IsOK(res1)) {
7431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7432 }
7433 arg1 = reinterpret_cast< wxRect * >(argp1);
7434 {
7435 arg2 = &temp2;
7436 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7437 }
7438 {
7439 (arg1)->Offset((wxPoint const &)*arg2);
7440 if (PyErr_Occurred()) SWIG_fail;
7441 }
7442 resultobj = SWIG_Py_Void();
7443 return resultobj;
7444 fail:
7445 return NULL;
7446 }
7447
7448
7449 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7450 PyObject *resultobj = 0;
7451 wxRect *arg1 = (wxRect *) 0 ;
7452 wxRect *arg2 = 0 ;
7453 wxRect result;
7454 void *argp1 = 0 ;
7455 int res1 = 0 ;
7456 wxRect temp2 ;
7457 PyObject * obj0 = 0 ;
7458 PyObject * obj1 = 0 ;
7459 char * kwnames[] = {
7460 (char *) "self",(char *) "rect", NULL
7461 };
7462
7463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7465 if (!SWIG_IsOK(res1)) {
7466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7467 }
7468 arg1 = reinterpret_cast< wxRect * >(argp1);
7469 {
7470 arg2 = &temp2;
7471 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7472 }
7473 {
7474 result = (arg1)->Intersect((wxRect const &)*arg2);
7475 if (PyErr_Occurred()) SWIG_fail;
7476 }
7477 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7478 return resultobj;
7479 fail:
7480 return NULL;
7481 }
7482
7483
7484 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7485 PyObject *resultobj = 0;
7486 wxRect *arg1 = (wxRect *) 0 ;
7487 wxRect *arg2 = 0 ;
7488 wxRect result;
7489 void *argp1 = 0 ;
7490 int res1 = 0 ;
7491 wxRect temp2 ;
7492 PyObject * obj0 = 0 ;
7493 PyObject * obj1 = 0 ;
7494 char * kwnames[] = {
7495 (char *) "self",(char *) "rect", NULL
7496 };
7497
7498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7500 if (!SWIG_IsOK(res1)) {
7501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7502 }
7503 arg1 = reinterpret_cast< wxRect * >(argp1);
7504 {
7505 arg2 = &temp2;
7506 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7507 }
7508 {
7509 result = (arg1)->Union((wxRect const &)*arg2);
7510 if (PyErr_Occurred()) SWIG_fail;
7511 }
7512 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7513 return resultobj;
7514 fail:
7515 return NULL;
7516 }
7517
7518
7519 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7520 PyObject *resultobj = 0;
7521 wxRect *arg1 = (wxRect *) 0 ;
7522 wxRect *arg2 = 0 ;
7523 wxRect result;
7524 void *argp1 = 0 ;
7525 int res1 = 0 ;
7526 wxRect temp2 ;
7527 PyObject * obj0 = 0 ;
7528 PyObject * obj1 = 0 ;
7529 char * kwnames[] = {
7530 (char *) "self",(char *) "rect", NULL
7531 };
7532
7533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7535 if (!SWIG_IsOK(res1)) {
7536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7537 }
7538 arg1 = reinterpret_cast< wxRect * >(argp1);
7539 {
7540 arg2 = &temp2;
7541 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7542 }
7543 {
7544 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7545 if (PyErr_Occurred()) SWIG_fail;
7546 }
7547 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7548 return resultobj;
7549 fail:
7550 return NULL;
7551 }
7552
7553
7554 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7555 PyObject *resultobj = 0;
7556 wxRect *arg1 = (wxRect *) 0 ;
7557 wxRect *arg2 = 0 ;
7558 wxRect *result = 0 ;
7559 void *argp1 = 0 ;
7560 int res1 = 0 ;
7561 wxRect temp2 ;
7562 PyObject * obj0 = 0 ;
7563 PyObject * obj1 = 0 ;
7564 char * kwnames[] = {
7565 (char *) "self",(char *) "rect", NULL
7566 };
7567
7568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7570 if (!SWIG_IsOK(res1)) {
7571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7572 }
7573 arg1 = reinterpret_cast< wxRect * >(argp1);
7574 {
7575 arg2 = &temp2;
7576 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7577 }
7578 {
7579 {
7580 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7581 result = (wxRect *) &_result_ref;
7582 }
7583 if (PyErr_Occurred()) SWIG_fail;
7584 }
7585 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7586 return resultobj;
7587 fail:
7588 return NULL;
7589 }
7590
7591
7592 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7593 PyObject *resultobj = 0;
7594 wxRect *arg1 = (wxRect *) 0 ;
7595 PyObject *arg2 = (PyObject *) 0 ;
7596 bool result;
7597 void *argp1 = 0 ;
7598 int res1 = 0 ;
7599 PyObject * obj0 = 0 ;
7600 PyObject * obj1 = 0 ;
7601 char * kwnames[] = {
7602 (char *) "self",(char *) "other", NULL
7603 };
7604
7605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7607 if (!SWIG_IsOK(res1)) {
7608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7609 }
7610 arg1 = reinterpret_cast< wxRect * >(argp1);
7611 arg2 = obj1;
7612 {
7613 result = (bool)wxRect___eq__(arg1,arg2);
7614 if (PyErr_Occurred()) SWIG_fail;
7615 }
7616 {
7617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7618 }
7619 return resultobj;
7620 fail:
7621 return NULL;
7622 }
7623
7624
7625 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7626 PyObject *resultobj = 0;
7627 wxRect *arg1 = (wxRect *) 0 ;
7628 PyObject *arg2 = (PyObject *) 0 ;
7629 bool result;
7630 void *argp1 = 0 ;
7631 int res1 = 0 ;
7632 PyObject * obj0 = 0 ;
7633 PyObject * obj1 = 0 ;
7634 char * kwnames[] = {
7635 (char *) "self",(char *) "other", NULL
7636 };
7637
7638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7640 if (!SWIG_IsOK(res1)) {
7641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7642 }
7643 arg1 = reinterpret_cast< wxRect * >(argp1);
7644 arg2 = obj1;
7645 {
7646 result = (bool)wxRect___ne__(arg1,arg2);
7647 if (PyErr_Occurred()) SWIG_fail;
7648 }
7649 {
7650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7651 }
7652 return resultobj;
7653 fail:
7654 return NULL;
7655 }
7656
7657
7658 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7659 PyObject *resultobj = 0;
7660 wxRect *arg1 = (wxRect *) 0 ;
7661 int arg2 ;
7662 int arg3 ;
7663 bool result;
7664 void *argp1 = 0 ;
7665 int res1 = 0 ;
7666 int val2 ;
7667 int ecode2 = 0 ;
7668 int val3 ;
7669 int ecode3 = 0 ;
7670 PyObject * obj0 = 0 ;
7671 PyObject * obj1 = 0 ;
7672 PyObject * obj2 = 0 ;
7673 char * kwnames[] = {
7674 (char *) "self",(char *) "x",(char *) "y", NULL
7675 };
7676
7677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7679 if (!SWIG_IsOK(res1)) {
7680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7681 }
7682 arg1 = reinterpret_cast< wxRect * >(argp1);
7683 ecode2 = SWIG_AsVal_int(obj1, &val2);
7684 if (!SWIG_IsOK(ecode2)) {
7685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7686 }
7687 arg2 = static_cast< int >(val2);
7688 ecode3 = SWIG_AsVal_int(obj2, &val3);
7689 if (!SWIG_IsOK(ecode3)) {
7690 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7691 }
7692 arg3 = static_cast< int >(val3);
7693 {
7694 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7695 if (PyErr_Occurred()) SWIG_fail;
7696 }
7697 {
7698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7699 }
7700 return resultobj;
7701 fail:
7702 return NULL;
7703 }
7704
7705
7706 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7707 PyObject *resultobj = 0;
7708 wxRect *arg1 = (wxRect *) 0 ;
7709 wxPoint *arg2 = 0 ;
7710 bool result;
7711 void *argp1 = 0 ;
7712 int res1 = 0 ;
7713 wxPoint temp2 ;
7714 PyObject * obj0 = 0 ;
7715 PyObject * obj1 = 0 ;
7716 char * kwnames[] = {
7717 (char *) "self",(char *) "pt", NULL
7718 };
7719
7720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7722 if (!SWIG_IsOK(res1)) {
7723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7724 }
7725 arg1 = reinterpret_cast< wxRect * >(argp1);
7726 {
7727 arg2 = &temp2;
7728 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7729 }
7730 {
7731 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7732 if (PyErr_Occurred()) SWIG_fail;
7733 }
7734 {
7735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7736 }
7737 return resultobj;
7738 fail:
7739 return NULL;
7740 }
7741
7742
7743 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7744 PyObject *resultobj = 0;
7745 wxRect *arg1 = (wxRect *) 0 ;
7746 wxRect *arg2 = 0 ;
7747 bool result;
7748 void *argp1 = 0 ;
7749 int res1 = 0 ;
7750 wxRect temp2 ;
7751 PyObject * obj0 = 0 ;
7752 PyObject * obj1 = 0 ;
7753 char * kwnames[] = {
7754 (char *) "self",(char *) "rect", NULL
7755 };
7756
7757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7759 if (!SWIG_IsOK(res1)) {
7760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7761 }
7762 arg1 = reinterpret_cast< wxRect * >(argp1);
7763 {
7764 arg2 = &temp2;
7765 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7766 }
7767 {
7768 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7769 if (PyErr_Occurred()) SWIG_fail;
7770 }
7771 {
7772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7773 }
7774 return resultobj;
7775 fail:
7776 return NULL;
7777 }
7778
7779
7780 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7781 PyObject *resultobj = 0;
7782 wxRect *arg1 = (wxRect *) 0 ;
7783 wxRect *arg2 = 0 ;
7784 bool result;
7785 void *argp1 = 0 ;
7786 int res1 = 0 ;
7787 wxRect temp2 ;
7788 PyObject * obj0 = 0 ;
7789 PyObject * obj1 = 0 ;
7790 char * kwnames[] = {
7791 (char *) "self",(char *) "rect", NULL
7792 };
7793
7794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7796 if (!SWIG_IsOK(res1)) {
7797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7798 }
7799 arg1 = reinterpret_cast< wxRect * >(argp1);
7800 {
7801 arg2 = &temp2;
7802 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7803 }
7804 {
7805 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7806 if (PyErr_Occurred()) SWIG_fail;
7807 }
7808 {
7809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7810 }
7811 return resultobj;
7812 fail:
7813 return NULL;
7814 }
7815
7816
7817 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7818 PyObject *resultobj = 0;
7819 wxRect *arg1 = (wxRect *) 0 ;
7820 wxRect *arg2 = 0 ;
7821 int arg3 = (int) wxBOTH ;
7822 wxRect result;
7823 void *argp1 = 0 ;
7824 int res1 = 0 ;
7825 wxRect temp2 ;
7826 int val3 ;
7827 int ecode3 = 0 ;
7828 PyObject * obj0 = 0 ;
7829 PyObject * obj1 = 0 ;
7830 PyObject * obj2 = 0 ;
7831 char * kwnames[] = {
7832 (char *) "self",(char *) "r",(char *) "dir", NULL
7833 };
7834
7835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7837 if (!SWIG_IsOK(res1)) {
7838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7839 }
7840 arg1 = reinterpret_cast< wxRect * >(argp1);
7841 {
7842 arg2 = &temp2;
7843 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7844 }
7845 if (obj2) {
7846 ecode3 = SWIG_AsVal_int(obj2, &val3);
7847 if (!SWIG_IsOK(ecode3)) {
7848 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7849 }
7850 arg3 = static_cast< int >(val3);
7851 }
7852 {
7853 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7854 if (PyErr_Occurred()) SWIG_fail;
7855 }
7856 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7857 return resultobj;
7858 fail:
7859 return NULL;
7860 }
7861
7862
7863 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7864 PyObject *resultobj = 0;
7865 wxRect *arg1 = (wxRect *) 0 ;
7866 int arg2 ;
7867 void *argp1 = 0 ;
7868 int res1 = 0 ;
7869 int val2 ;
7870 int ecode2 = 0 ;
7871 PyObject *swig_obj[2] ;
7872
7873 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7875 if (!SWIG_IsOK(res1)) {
7876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7877 }
7878 arg1 = reinterpret_cast< wxRect * >(argp1);
7879 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7880 if (!SWIG_IsOK(ecode2)) {
7881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7882 }
7883 arg2 = static_cast< int >(val2);
7884 if (arg1) (arg1)->x = arg2;
7885
7886 resultobj = SWIG_Py_Void();
7887 return resultobj;
7888 fail:
7889 return NULL;
7890 }
7891
7892
7893 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7894 PyObject *resultobj = 0;
7895 wxRect *arg1 = (wxRect *) 0 ;
7896 int result;
7897 void *argp1 = 0 ;
7898 int res1 = 0 ;
7899 PyObject *swig_obj[1] ;
7900
7901 if (!args) SWIG_fail;
7902 swig_obj[0] = args;
7903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7904 if (!SWIG_IsOK(res1)) {
7905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7906 }
7907 arg1 = reinterpret_cast< wxRect * >(argp1);
7908 result = (int) ((arg1)->x);
7909 resultobj = SWIG_From_int(static_cast< int >(result));
7910 return resultobj;
7911 fail:
7912 return NULL;
7913 }
7914
7915
7916 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7917 PyObject *resultobj = 0;
7918 wxRect *arg1 = (wxRect *) 0 ;
7919 int arg2 ;
7920 void *argp1 = 0 ;
7921 int res1 = 0 ;
7922 int val2 ;
7923 int ecode2 = 0 ;
7924 PyObject *swig_obj[2] ;
7925
7926 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7928 if (!SWIG_IsOK(res1)) {
7929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7930 }
7931 arg1 = reinterpret_cast< wxRect * >(argp1);
7932 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7933 if (!SWIG_IsOK(ecode2)) {
7934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7935 }
7936 arg2 = static_cast< int >(val2);
7937 if (arg1) (arg1)->y = arg2;
7938
7939 resultobj = SWIG_Py_Void();
7940 return resultobj;
7941 fail:
7942 return NULL;
7943 }
7944
7945
7946 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7947 PyObject *resultobj = 0;
7948 wxRect *arg1 = (wxRect *) 0 ;
7949 int result;
7950 void *argp1 = 0 ;
7951 int res1 = 0 ;
7952 PyObject *swig_obj[1] ;
7953
7954 if (!args) SWIG_fail;
7955 swig_obj[0] = args;
7956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7957 if (!SWIG_IsOK(res1)) {
7958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7959 }
7960 arg1 = reinterpret_cast< wxRect * >(argp1);
7961 result = (int) ((arg1)->y);
7962 resultobj = SWIG_From_int(static_cast< int >(result));
7963 return resultobj;
7964 fail:
7965 return NULL;
7966 }
7967
7968
7969 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7970 PyObject *resultobj = 0;
7971 wxRect *arg1 = (wxRect *) 0 ;
7972 int arg2 ;
7973 void *argp1 = 0 ;
7974 int res1 = 0 ;
7975 int val2 ;
7976 int ecode2 = 0 ;
7977 PyObject *swig_obj[2] ;
7978
7979 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7981 if (!SWIG_IsOK(res1)) {
7982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7983 }
7984 arg1 = reinterpret_cast< wxRect * >(argp1);
7985 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7986 if (!SWIG_IsOK(ecode2)) {
7987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7988 }
7989 arg2 = static_cast< int >(val2);
7990 if (arg1) (arg1)->width = arg2;
7991
7992 resultobj = SWIG_Py_Void();
7993 return resultobj;
7994 fail:
7995 return NULL;
7996 }
7997
7998
7999 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8000 PyObject *resultobj = 0;
8001 wxRect *arg1 = (wxRect *) 0 ;
8002 int result;
8003 void *argp1 = 0 ;
8004 int res1 = 0 ;
8005 PyObject *swig_obj[1] ;
8006
8007 if (!args) SWIG_fail;
8008 swig_obj[0] = args;
8009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8010 if (!SWIG_IsOK(res1)) {
8011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
8012 }
8013 arg1 = reinterpret_cast< wxRect * >(argp1);
8014 result = (int) ((arg1)->width);
8015 resultobj = SWIG_From_int(static_cast< int >(result));
8016 return resultobj;
8017 fail:
8018 return NULL;
8019 }
8020
8021
8022 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8023 PyObject *resultobj = 0;
8024 wxRect *arg1 = (wxRect *) 0 ;
8025 int arg2 ;
8026 void *argp1 = 0 ;
8027 int res1 = 0 ;
8028 int val2 ;
8029 int ecode2 = 0 ;
8030 PyObject *swig_obj[2] ;
8031
8032 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
8033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8034 if (!SWIG_IsOK(res1)) {
8035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
8036 }
8037 arg1 = reinterpret_cast< wxRect * >(argp1);
8038 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8039 if (!SWIG_IsOK(ecode2)) {
8040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
8041 }
8042 arg2 = static_cast< int >(val2);
8043 if (arg1) (arg1)->height = arg2;
8044
8045 resultobj = SWIG_Py_Void();
8046 return resultobj;
8047 fail:
8048 return NULL;
8049 }
8050
8051
8052 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8053 PyObject *resultobj = 0;
8054 wxRect *arg1 = (wxRect *) 0 ;
8055 int result;
8056 void *argp1 = 0 ;
8057 int res1 = 0 ;
8058 PyObject *swig_obj[1] ;
8059
8060 if (!args) SWIG_fail;
8061 swig_obj[0] = args;
8062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8063 if (!SWIG_IsOK(res1)) {
8064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8065 }
8066 arg1 = reinterpret_cast< wxRect * >(argp1);
8067 result = (int) ((arg1)->height);
8068 resultobj = SWIG_From_int(static_cast< int >(result));
8069 return resultobj;
8070 fail:
8071 return NULL;
8072 }
8073
8074
8075 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8076 PyObject *resultobj = 0;
8077 wxRect *arg1 = (wxRect *) 0 ;
8078 int arg2 = (int) 0 ;
8079 int arg3 = (int) 0 ;
8080 int arg4 = (int) 0 ;
8081 int arg5 = (int) 0 ;
8082 void *argp1 = 0 ;
8083 int res1 = 0 ;
8084 int val2 ;
8085 int ecode2 = 0 ;
8086 int val3 ;
8087 int ecode3 = 0 ;
8088 int val4 ;
8089 int ecode4 = 0 ;
8090 int val5 ;
8091 int ecode5 = 0 ;
8092 PyObject * obj0 = 0 ;
8093 PyObject * obj1 = 0 ;
8094 PyObject * obj2 = 0 ;
8095 PyObject * obj3 = 0 ;
8096 PyObject * obj4 = 0 ;
8097 char * kwnames[] = {
8098 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8099 };
8100
8101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8103 if (!SWIG_IsOK(res1)) {
8104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8105 }
8106 arg1 = reinterpret_cast< wxRect * >(argp1);
8107 if (obj1) {
8108 ecode2 = SWIG_AsVal_int(obj1, &val2);
8109 if (!SWIG_IsOK(ecode2)) {
8110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8111 }
8112 arg2 = static_cast< int >(val2);
8113 }
8114 if (obj2) {
8115 ecode3 = SWIG_AsVal_int(obj2, &val3);
8116 if (!SWIG_IsOK(ecode3)) {
8117 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8118 }
8119 arg3 = static_cast< int >(val3);
8120 }
8121 if (obj3) {
8122 ecode4 = SWIG_AsVal_int(obj3, &val4);
8123 if (!SWIG_IsOK(ecode4)) {
8124 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8125 }
8126 arg4 = static_cast< int >(val4);
8127 }
8128 if (obj4) {
8129 ecode5 = SWIG_AsVal_int(obj4, &val5);
8130 if (!SWIG_IsOK(ecode5)) {
8131 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8132 }
8133 arg5 = static_cast< int >(val5);
8134 }
8135 {
8136 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8137 if (PyErr_Occurred()) SWIG_fail;
8138 }
8139 resultobj = SWIG_Py_Void();
8140 return resultobj;
8141 fail:
8142 return NULL;
8143 }
8144
8145
8146 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8147 PyObject *resultobj = 0;
8148 wxRect *arg1 = (wxRect *) 0 ;
8149 PyObject *result = 0 ;
8150 void *argp1 = 0 ;
8151 int res1 = 0 ;
8152 PyObject *swig_obj[1] ;
8153
8154 if (!args) SWIG_fail;
8155 swig_obj[0] = args;
8156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8157 if (!SWIG_IsOK(res1)) {
8158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8159 }
8160 arg1 = reinterpret_cast< wxRect * >(argp1);
8161 {
8162 result = (PyObject *)wxRect_Get(arg1);
8163 if (PyErr_Occurred()) SWIG_fail;
8164 }
8165 resultobj = result;
8166 return resultobj;
8167 fail:
8168 return NULL;
8169 }
8170
8171
8172 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8173 PyObject *obj;
8174 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8175 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8176 return SWIG_Py_Void();
8177 }
8178
8179 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8180 return SWIG_Python_InitShadowInstance(args);
8181 }
8182
8183 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8184 PyObject *resultobj = 0;
8185 wxRect *arg1 = (wxRect *) 0 ;
8186 wxRect *arg2 = (wxRect *) 0 ;
8187 PyObject *result = 0 ;
8188 void *argp1 = 0 ;
8189 int res1 = 0 ;
8190 void *argp2 = 0 ;
8191 int res2 = 0 ;
8192 PyObject * obj0 = 0 ;
8193 PyObject * obj1 = 0 ;
8194 char * kwnames[] = {
8195 (char *) "r1",(char *) "r2", NULL
8196 };
8197
8198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8200 if (!SWIG_IsOK(res1)) {
8201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8202 }
8203 arg1 = reinterpret_cast< wxRect * >(argp1);
8204 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8205 if (!SWIG_IsOK(res2)) {
8206 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8207 }
8208 arg2 = reinterpret_cast< wxRect * >(argp2);
8209 {
8210 if (!wxPyCheckForApp()) SWIG_fail;
8211 PyThreadState* __tstate = wxPyBeginAllowThreads();
8212 result = (PyObject *)wxIntersectRect(arg1,arg2);
8213 wxPyEndAllowThreads(__tstate);
8214 if (PyErr_Occurred()) SWIG_fail;
8215 }
8216 resultobj = result;
8217 return resultobj;
8218 fail:
8219 return NULL;
8220 }
8221
8222
8223 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8224 PyObject *resultobj = 0;
8225 double arg1 = (double) 0.0 ;
8226 double arg2 = (double) 0.0 ;
8227 wxPoint2D *result = 0 ;
8228 double val1 ;
8229 int ecode1 = 0 ;
8230 double val2 ;
8231 int ecode2 = 0 ;
8232 PyObject * obj0 = 0 ;
8233 PyObject * obj1 = 0 ;
8234 char * kwnames[] = {
8235 (char *) "x",(char *) "y", NULL
8236 };
8237
8238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8239 if (obj0) {
8240 ecode1 = SWIG_AsVal_double(obj0, &val1);
8241 if (!SWIG_IsOK(ecode1)) {
8242 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8243 }
8244 arg1 = static_cast< double >(val1);
8245 }
8246 if (obj1) {
8247 ecode2 = SWIG_AsVal_double(obj1, &val2);
8248 if (!SWIG_IsOK(ecode2)) {
8249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8250 }
8251 arg2 = static_cast< double >(val2);
8252 }
8253 {
8254 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8255 if (PyErr_Occurred()) SWIG_fail;
8256 }
8257 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8258 return resultobj;
8259 fail:
8260 return NULL;
8261 }
8262
8263
8264 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8265 PyObject *resultobj = 0;
8266 wxPoint2D *arg1 = 0 ;
8267 wxPoint2D *result = 0 ;
8268 wxPoint2D temp1 ;
8269 PyObject * obj0 = 0 ;
8270 char * kwnames[] = {
8271 (char *) "pt", NULL
8272 };
8273
8274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8275 {
8276 arg1 = &temp1;
8277 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8278 }
8279 {
8280 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8281 if (PyErr_Occurred()) SWIG_fail;
8282 }
8283 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8284 return resultobj;
8285 fail:
8286 return NULL;
8287 }
8288
8289
8290 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8291 PyObject *resultobj = 0;
8292 wxPoint *arg1 = 0 ;
8293 wxPoint2D *result = 0 ;
8294 wxPoint temp1 ;
8295 PyObject * obj0 = 0 ;
8296 char * kwnames[] = {
8297 (char *) "pt", NULL
8298 };
8299
8300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8301 {
8302 arg1 = &temp1;
8303 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8304 }
8305 {
8306 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8307 if (PyErr_Occurred()) SWIG_fail;
8308 }
8309 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8310 return resultobj;
8311 fail:
8312 return NULL;
8313 }
8314
8315
8316 SWIGINTERN PyObject *_wrap_delete_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8317 PyObject *resultobj = 0;
8318 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8319 void *argp1 = 0 ;
8320 int res1 = 0 ;
8321 PyObject *swig_obj[1] ;
8322
8323 if (!args) SWIG_fail;
8324 swig_obj[0] = args;
8325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8326 if (!SWIG_IsOK(res1)) {
8327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point2D" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8328 }
8329 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8330 {
8331 delete arg1;
8332
8333 if (PyErr_Occurred()) SWIG_fail;
8334 }
8335 resultobj = SWIG_Py_Void();
8336 return resultobj;
8337 fail:
8338 return NULL;
8339 }
8340
8341
8342 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8343 PyObject *resultobj = 0;
8344 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8345 int *arg2 = (int *) 0 ;
8346 int *arg3 = (int *) 0 ;
8347 void *argp1 = 0 ;
8348 int res1 = 0 ;
8349 int temp2 ;
8350 int res2 = SWIG_TMPOBJ ;
8351 int temp3 ;
8352 int res3 = SWIG_TMPOBJ ;
8353 PyObject *swig_obj[1] ;
8354
8355 arg2 = &temp2;
8356 arg3 = &temp3;
8357 if (!args) SWIG_fail;
8358 swig_obj[0] = args;
8359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8360 if (!SWIG_IsOK(res1)) {
8361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8362 }
8363 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8364 {
8365 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8366 if (PyErr_Occurred()) SWIG_fail;
8367 }
8368 resultobj = SWIG_Py_Void();
8369 if (SWIG_IsTmpObj(res2)) {
8370 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8371 } else {
8372 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8373 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8374 }
8375 if (SWIG_IsTmpObj(res3)) {
8376 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8377 } else {
8378 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8379 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8380 }
8381 return resultobj;
8382 fail:
8383 return NULL;
8384 }
8385
8386
8387 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8388 PyObject *resultobj = 0;
8389 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8390 int *arg2 = (int *) 0 ;
8391 int *arg3 = (int *) 0 ;
8392 void *argp1 = 0 ;
8393 int res1 = 0 ;
8394 int temp2 ;
8395 int res2 = SWIG_TMPOBJ ;
8396 int temp3 ;
8397 int res3 = SWIG_TMPOBJ ;
8398 PyObject *swig_obj[1] ;
8399
8400 arg2 = &temp2;
8401 arg3 = &temp3;
8402 if (!args) SWIG_fail;
8403 swig_obj[0] = args;
8404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8405 if (!SWIG_IsOK(res1)) {
8406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8407 }
8408 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8409 {
8410 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8411 if (PyErr_Occurred()) SWIG_fail;
8412 }
8413 resultobj = SWIG_Py_Void();
8414 if (SWIG_IsTmpObj(res2)) {
8415 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8416 } else {
8417 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8418 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8419 }
8420 if (SWIG_IsTmpObj(res3)) {
8421 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8422 } else {
8423 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8424 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8425 }
8426 return resultobj;
8427 fail:
8428 return NULL;
8429 }
8430
8431
8432 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8433 PyObject *resultobj = 0;
8434 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8435 double result;
8436 void *argp1 = 0 ;
8437 int res1 = 0 ;
8438 PyObject *swig_obj[1] ;
8439
8440 if (!args) SWIG_fail;
8441 swig_obj[0] = args;
8442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8443 if (!SWIG_IsOK(res1)) {
8444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8445 }
8446 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8447 {
8448 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8449 if (PyErr_Occurred()) SWIG_fail;
8450 }
8451 resultobj = SWIG_From_double(static_cast< double >(result));
8452 return resultobj;
8453 fail:
8454 return NULL;
8455 }
8456
8457
8458 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8459 PyObject *resultobj = 0;
8460 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8461 double result;
8462 void *argp1 = 0 ;
8463 int res1 = 0 ;
8464 PyObject *swig_obj[1] ;
8465
8466 if (!args) SWIG_fail;
8467 swig_obj[0] = args;
8468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8469 if (!SWIG_IsOK(res1)) {
8470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8471 }
8472 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8473 {
8474 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8475 if (PyErr_Occurred()) SWIG_fail;
8476 }
8477 resultobj = SWIG_From_double(static_cast< double >(result));
8478 return resultobj;
8479 fail:
8480 return NULL;
8481 }
8482
8483
8484 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8485 PyObject *resultobj = 0;
8486 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8487 double arg2 ;
8488 void *argp1 = 0 ;
8489 int res1 = 0 ;
8490 double val2 ;
8491 int ecode2 = 0 ;
8492 PyObject * obj0 = 0 ;
8493 PyObject * obj1 = 0 ;
8494 char * kwnames[] = {
8495 (char *) "self",(char *) "length", NULL
8496 };
8497
8498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8500 if (!SWIG_IsOK(res1)) {
8501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8502 }
8503 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8504 ecode2 = SWIG_AsVal_double(obj1, &val2);
8505 if (!SWIG_IsOK(ecode2)) {
8506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8507 }
8508 arg2 = static_cast< double >(val2);
8509 {
8510 (arg1)->SetVectorLength(arg2);
8511 if (PyErr_Occurred()) SWIG_fail;
8512 }
8513 resultobj = SWIG_Py_Void();
8514 return resultobj;
8515 fail:
8516 return NULL;
8517 }
8518
8519
8520 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8521 PyObject *resultobj = 0;
8522 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8523 double arg2 ;
8524 void *argp1 = 0 ;
8525 int res1 = 0 ;
8526 double val2 ;
8527 int ecode2 = 0 ;
8528 PyObject * obj0 = 0 ;
8529 PyObject * obj1 = 0 ;
8530 char * kwnames[] = {
8531 (char *) "self",(char *) "degrees", NULL
8532 };
8533
8534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8536 if (!SWIG_IsOK(res1)) {
8537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8538 }
8539 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8540 ecode2 = SWIG_AsVal_double(obj1, &val2);
8541 if (!SWIG_IsOK(ecode2)) {
8542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8543 }
8544 arg2 = static_cast< double >(val2);
8545 {
8546 (arg1)->SetVectorAngle(arg2);
8547 if (PyErr_Occurred()) SWIG_fail;
8548 }
8549 resultobj = SWIG_Py_Void();
8550 return resultobj;
8551 fail:
8552 return NULL;
8553 }
8554
8555
8556 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8557 PyObject *resultobj = 0;
8558 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8559 wxPoint2D *arg2 = 0 ;
8560 double result;
8561 void *argp1 = 0 ;
8562 int res1 = 0 ;
8563 wxPoint2D temp2 ;
8564 PyObject * obj0 = 0 ;
8565 PyObject * obj1 = 0 ;
8566 char * kwnames[] = {
8567 (char *) "self",(char *) "pt", NULL
8568 };
8569
8570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8572 if (!SWIG_IsOK(res1)) {
8573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8574 }
8575 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8576 {
8577 arg2 = &temp2;
8578 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8579 }
8580 {
8581 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8582 if (PyErr_Occurred()) SWIG_fail;
8583 }
8584 resultobj = SWIG_From_double(static_cast< double >(result));
8585 return resultobj;
8586 fail:
8587 return NULL;
8588 }
8589
8590
8591 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8592 PyObject *resultobj = 0;
8593 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8594 wxPoint2D *arg2 = 0 ;
8595 double result;
8596 void *argp1 = 0 ;
8597 int res1 = 0 ;
8598 wxPoint2D temp2 ;
8599 PyObject * obj0 = 0 ;
8600 PyObject * obj1 = 0 ;
8601 char * kwnames[] = {
8602 (char *) "self",(char *) "pt", NULL
8603 };
8604
8605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",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_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8609 }
8610 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8611 {
8612 arg2 = &temp2;
8613 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8614 }
8615 {
8616 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8617 if (PyErr_Occurred()) SWIG_fail;
8618 }
8619 resultobj = SWIG_From_double(static_cast< double >(result));
8620 return resultobj;
8621 fail:
8622 return NULL;
8623 }
8624
8625
8626 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8627 PyObject *resultobj = 0;
8628 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8629 wxPoint2D *arg2 = 0 ;
8630 double result;
8631 void *argp1 = 0 ;
8632 int res1 = 0 ;
8633 wxPoint2D temp2 ;
8634 PyObject * obj0 = 0 ;
8635 PyObject * obj1 = 0 ;
8636 char * kwnames[] = {
8637 (char *) "self",(char *) "vec", NULL
8638 };
8639
8640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8642 if (!SWIG_IsOK(res1)) {
8643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8644 }
8645 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8646 {
8647 arg2 = &temp2;
8648 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8649 }
8650 {
8651 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8652 if (PyErr_Occurred()) SWIG_fail;
8653 }
8654 resultobj = SWIG_From_double(static_cast< double >(result));
8655 return resultobj;
8656 fail:
8657 return NULL;
8658 }
8659
8660
8661 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8662 PyObject *resultobj = 0;
8663 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8664 wxPoint2D *arg2 = 0 ;
8665 double result;
8666 void *argp1 = 0 ;
8667 int res1 = 0 ;
8668 wxPoint2D temp2 ;
8669 PyObject * obj0 = 0 ;
8670 PyObject * obj1 = 0 ;
8671 char * kwnames[] = {
8672 (char *) "self",(char *) "vec", NULL
8673 };
8674
8675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8677 if (!SWIG_IsOK(res1)) {
8678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8679 }
8680 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8681 {
8682 arg2 = &temp2;
8683 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8684 }
8685 {
8686 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8687 if (PyErr_Occurred()) SWIG_fail;
8688 }
8689 resultobj = SWIG_From_double(static_cast< double >(result));
8690 return resultobj;
8691 fail:
8692 return NULL;
8693 }
8694
8695
8696 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8697 PyObject *resultobj = 0;
8698 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8699 wxPoint2D result;
8700 void *argp1 = 0 ;
8701 int res1 = 0 ;
8702 PyObject *swig_obj[1] ;
8703
8704 if (!args) SWIG_fail;
8705 swig_obj[0] = args;
8706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8707 if (!SWIG_IsOK(res1)) {
8708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8709 }
8710 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8711 {
8712 result = (arg1)->operator -();
8713 if (PyErr_Occurred()) SWIG_fail;
8714 }
8715 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8716 return resultobj;
8717 fail:
8718 return NULL;
8719 }
8720
8721
8722 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8723 PyObject *resultobj = 0;
8724 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8725 wxPoint2D *arg2 = 0 ;
8726 wxPoint2D *result = 0 ;
8727 void *argp1 = 0 ;
8728 int res1 = 0 ;
8729 wxPoint2D temp2 ;
8730 PyObject * obj0 = 0 ;
8731 PyObject * obj1 = 0 ;
8732 char * kwnames[] = {
8733 (char *) "self",(char *) "pt", NULL
8734 };
8735
8736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8738 if (!SWIG_IsOK(res1)) {
8739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8740 }
8741 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8742 {
8743 arg2 = &temp2;
8744 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8745 }
8746 {
8747 {
8748 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8749 result = (wxPoint2D *) &_result_ref;
8750 }
8751 if (PyErr_Occurred()) SWIG_fail;
8752 }
8753 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8754 return resultobj;
8755 fail:
8756 return NULL;
8757 }
8758
8759
8760 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8761 PyObject *resultobj = 0;
8762 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8763 wxPoint2D *arg2 = 0 ;
8764 wxPoint2D *result = 0 ;
8765 void *argp1 = 0 ;
8766 int res1 = 0 ;
8767 wxPoint2D temp2 ;
8768 PyObject * obj0 = 0 ;
8769 PyObject * obj1 = 0 ;
8770 char * kwnames[] = {
8771 (char *) "self",(char *) "pt", NULL
8772 };
8773
8774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8776 if (!SWIG_IsOK(res1)) {
8777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8778 }
8779 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8780 {
8781 arg2 = &temp2;
8782 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8783 }
8784 {
8785 {
8786 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8787 result = (wxPoint2D *) &_result_ref;
8788 }
8789 if (PyErr_Occurred()) SWIG_fail;
8790 }
8791 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8792 return resultobj;
8793 fail:
8794 return NULL;
8795 }
8796
8797
8798 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8799 PyObject *resultobj = 0;
8800 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8801 wxPoint2D *arg2 = 0 ;
8802 wxPoint2D *result = 0 ;
8803 void *argp1 = 0 ;
8804 int res1 = 0 ;
8805 wxPoint2D temp2 ;
8806 PyObject * obj0 = 0 ;
8807 PyObject * obj1 = 0 ;
8808 char * kwnames[] = {
8809 (char *) "self",(char *) "pt", NULL
8810 };
8811
8812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8814 if (!SWIG_IsOK(res1)) {
8815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8816 }
8817 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8818 {
8819 arg2 = &temp2;
8820 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8821 }
8822 {
8823 {
8824 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8825 result = (wxPoint2D *) &_result_ref;
8826 }
8827 if (PyErr_Occurred()) SWIG_fail;
8828 }
8829 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8830 return resultobj;
8831 fail:
8832 return NULL;
8833 }
8834
8835
8836 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8837 PyObject *resultobj = 0;
8838 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8839 wxPoint2D *arg2 = 0 ;
8840 wxPoint2D *result = 0 ;
8841 void *argp1 = 0 ;
8842 int res1 = 0 ;
8843 wxPoint2D temp2 ;
8844 PyObject * obj0 = 0 ;
8845 PyObject * obj1 = 0 ;
8846 char * kwnames[] = {
8847 (char *) "self",(char *) "pt", NULL
8848 };
8849
8850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8852 if (!SWIG_IsOK(res1)) {
8853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8854 }
8855 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8856 {
8857 arg2 = &temp2;
8858 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8859 }
8860 {
8861 {
8862 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8863 result = (wxPoint2D *) &_result_ref;
8864 }
8865 if (PyErr_Occurred()) SWIG_fail;
8866 }
8867 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8868 return resultobj;
8869 fail:
8870 return NULL;
8871 }
8872
8873
8874 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8875 PyObject *resultobj = 0;
8876 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8877 PyObject *arg2 = (PyObject *) 0 ;
8878 bool result;
8879 void *argp1 = 0 ;
8880 int res1 = 0 ;
8881 PyObject * obj0 = 0 ;
8882 PyObject * obj1 = 0 ;
8883 char * kwnames[] = {
8884 (char *) "self",(char *) "other", NULL
8885 };
8886
8887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8889 if (!SWIG_IsOK(res1)) {
8890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8891 }
8892 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8893 arg2 = obj1;
8894 {
8895 result = (bool)wxPoint2D___eq__(arg1,arg2);
8896 if (PyErr_Occurred()) SWIG_fail;
8897 }
8898 {
8899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8900 }
8901 return resultobj;
8902 fail:
8903 return NULL;
8904 }
8905
8906
8907 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8908 PyObject *resultobj = 0;
8909 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8910 PyObject *arg2 = (PyObject *) 0 ;
8911 bool result;
8912 void *argp1 = 0 ;
8913 int res1 = 0 ;
8914 PyObject * obj0 = 0 ;
8915 PyObject * obj1 = 0 ;
8916 char * kwnames[] = {
8917 (char *) "self",(char *) "other", NULL
8918 };
8919
8920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8922 if (!SWIG_IsOK(res1)) {
8923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8924 }
8925 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8926 arg2 = obj1;
8927 {
8928 result = (bool)wxPoint2D___ne__(arg1,arg2);
8929 if (PyErr_Occurred()) SWIG_fail;
8930 }
8931 {
8932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8933 }
8934 return resultobj;
8935 fail:
8936 return NULL;
8937 }
8938
8939
8940 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8941 PyObject *resultobj = 0;
8942 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8943 double arg2 ;
8944 void *argp1 = 0 ;
8945 int res1 = 0 ;
8946 double val2 ;
8947 int ecode2 = 0 ;
8948 PyObject *swig_obj[2] ;
8949
8950 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8952 if (!SWIG_IsOK(res1)) {
8953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8954 }
8955 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8956 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8957 if (!SWIG_IsOK(ecode2)) {
8958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8959 }
8960 arg2 = static_cast< double >(val2);
8961 if (arg1) (arg1)->m_x = arg2;
8962
8963 resultobj = SWIG_Py_Void();
8964 return resultobj;
8965 fail:
8966 return NULL;
8967 }
8968
8969
8970 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8971 PyObject *resultobj = 0;
8972 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8973 double result;
8974 void *argp1 = 0 ;
8975 int res1 = 0 ;
8976 PyObject *swig_obj[1] ;
8977
8978 if (!args) SWIG_fail;
8979 swig_obj[0] = args;
8980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8981 if (!SWIG_IsOK(res1)) {
8982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8983 }
8984 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8985 result = (double) ((arg1)->m_x);
8986 resultobj = SWIG_From_double(static_cast< double >(result));
8987 return resultobj;
8988 fail:
8989 return NULL;
8990 }
8991
8992
8993 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8994 PyObject *resultobj = 0;
8995 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8996 double arg2 ;
8997 void *argp1 = 0 ;
8998 int res1 = 0 ;
8999 double val2 ;
9000 int ecode2 = 0 ;
9001 PyObject *swig_obj[2] ;
9002
9003 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
9004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9005 if (!SWIG_IsOK(res1)) {
9006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9007 }
9008 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9009 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9010 if (!SWIG_IsOK(ecode2)) {
9011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
9012 }
9013 arg2 = static_cast< double >(val2);
9014 if (arg1) (arg1)->m_y = arg2;
9015
9016 resultobj = SWIG_Py_Void();
9017 return resultobj;
9018 fail:
9019 return NULL;
9020 }
9021
9022
9023 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9024 PyObject *resultobj = 0;
9025 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9026 double result;
9027 void *argp1 = 0 ;
9028 int res1 = 0 ;
9029 PyObject *swig_obj[1] ;
9030
9031 if (!args) SWIG_fail;
9032 swig_obj[0] = args;
9033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9034 if (!SWIG_IsOK(res1)) {
9035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9036 }
9037 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9038 result = (double) ((arg1)->m_y);
9039 resultobj = SWIG_From_double(static_cast< double >(result));
9040 return resultobj;
9041 fail:
9042 return NULL;
9043 }
9044
9045
9046 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9047 PyObject *resultobj = 0;
9048 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9049 double arg2 = (double) 0 ;
9050 double arg3 = (double) 0 ;
9051 void *argp1 = 0 ;
9052 int res1 = 0 ;
9053 double val2 ;
9054 int ecode2 = 0 ;
9055 double val3 ;
9056 int ecode3 = 0 ;
9057 PyObject * obj0 = 0 ;
9058 PyObject * obj1 = 0 ;
9059 PyObject * obj2 = 0 ;
9060 char * kwnames[] = {
9061 (char *) "self",(char *) "x",(char *) "y", NULL
9062 };
9063
9064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9066 if (!SWIG_IsOK(res1)) {
9067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9068 }
9069 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9070 if (obj1) {
9071 ecode2 = SWIG_AsVal_double(obj1, &val2);
9072 if (!SWIG_IsOK(ecode2)) {
9073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9074 }
9075 arg2 = static_cast< double >(val2);
9076 }
9077 if (obj2) {
9078 ecode3 = SWIG_AsVal_double(obj2, &val3);
9079 if (!SWIG_IsOK(ecode3)) {
9080 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9081 }
9082 arg3 = static_cast< double >(val3);
9083 }
9084 {
9085 wxPoint2D_Set(arg1,arg2,arg3);
9086 if (PyErr_Occurred()) SWIG_fail;
9087 }
9088 resultobj = SWIG_Py_Void();
9089 return resultobj;
9090 fail:
9091 return NULL;
9092 }
9093
9094
9095 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9096 PyObject *resultobj = 0;
9097 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9098 PyObject *result = 0 ;
9099 void *argp1 = 0 ;
9100 int res1 = 0 ;
9101 PyObject *swig_obj[1] ;
9102
9103 if (!args) SWIG_fail;
9104 swig_obj[0] = args;
9105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9106 if (!SWIG_IsOK(res1)) {
9107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9108 }
9109 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9110 {
9111 result = (PyObject *)wxPoint2D_Get(arg1);
9112 if (PyErr_Occurred()) SWIG_fail;
9113 }
9114 resultobj = result;
9115 return resultobj;
9116 fail:
9117 return NULL;
9118 }
9119
9120
9121 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9122 PyObject *obj;
9123 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9124 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9125 return SWIG_Py_Void();
9126 }
9127
9128 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9129 return SWIG_Python_InitShadowInstance(args);
9130 }
9131
9132 SWIGINTERN PyObject *_wrap_new_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9133 PyObject *resultobj = 0;
9134 wxDouble arg1 = (wxDouble) 0.0 ;
9135 wxDouble arg2 = (wxDouble) 0.0 ;
9136 wxDouble arg3 = (wxDouble) 0.0 ;
9137 wxDouble arg4 = (wxDouble) 0.0 ;
9138 wxRect2D *result = 0 ;
9139 void *argp1 ;
9140 int res1 = 0 ;
9141 void *argp2 ;
9142 int res2 = 0 ;
9143 void *argp3 ;
9144 int res3 = 0 ;
9145 void *argp4 ;
9146 int res4 = 0 ;
9147 PyObject * obj0 = 0 ;
9148 PyObject * obj1 = 0 ;
9149 PyObject * obj2 = 0 ;
9150 PyObject * obj3 = 0 ;
9151 char * kwnames[] = {
9152 (char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
9153 };
9154
9155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect2D",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9156 if (obj0) {
9157 {
9158 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDouble, 0 | 0);
9159 if (!SWIG_IsOK(res1)) {
9160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9161 }
9162 if (!argp1) {
9163 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9164 } else {
9165 wxDouble * temp = reinterpret_cast< wxDouble * >(argp1);
9166 arg1 = *temp;
9167 if (SWIG_IsNewObj(res1)) delete temp;
9168 }
9169 }
9170 }
9171 if (obj1) {
9172 {
9173 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9174 if (!SWIG_IsOK(res2)) {
9175 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9176 }
9177 if (!argp2) {
9178 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9179 } else {
9180 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9181 arg2 = *temp;
9182 if (SWIG_IsNewObj(res2)) delete temp;
9183 }
9184 }
9185 }
9186 if (obj2) {
9187 {
9188 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
9189 if (!SWIG_IsOK(res3)) {
9190 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9191 }
9192 if (!argp3) {
9193 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9194 } else {
9195 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
9196 arg3 = *temp;
9197 if (SWIG_IsNewObj(res3)) delete temp;
9198 }
9199 }
9200 }
9201 if (obj3) {
9202 {
9203 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
9204 if (!SWIG_IsOK(res4)) {
9205 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9206 }
9207 if (!argp4) {
9208 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9209 } else {
9210 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
9211 arg4 = *temp;
9212 if (SWIG_IsNewObj(res4)) delete temp;
9213 }
9214 }
9215 }
9216 {
9217 result = (wxRect2D *)new wxRect2D(arg1,arg2,arg3,arg4);
9218 if (PyErr_Occurred()) SWIG_fail;
9219 }
9220 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect2D, SWIG_POINTER_NEW | 0 );
9221 return resultobj;
9222 fail:
9223 return NULL;
9224 }
9225
9226
9227 SWIGINTERN PyObject *_wrap_delete_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9228 PyObject *resultobj = 0;
9229 wxRect2D *arg1 = (wxRect2D *) 0 ;
9230 void *argp1 = 0 ;
9231 int res1 = 0 ;
9232 PyObject *swig_obj[1] ;
9233
9234 if (!args) SWIG_fail;
9235 swig_obj[0] = args;
9236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, SWIG_POINTER_DISOWN | 0 );
9237 if (!SWIG_IsOK(res1)) {
9238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect2D" "', expected argument " "1"" of type '" "wxRect2D *""'");
9239 }
9240 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9241 {
9242 delete arg1;
9243
9244 if (PyErr_Occurred()) SWIG_fail;
9245 }
9246 resultobj = SWIG_Py_Void();
9247 return resultobj;
9248 fail:
9249 return NULL;
9250 }
9251
9252
9253 SWIGINTERN PyObject *_wrap_Rect2D_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9254 PyObject *resultobj = 0;
9255 wxRect2D *arg1 = (wxRect2D *) 0 ;
9256 wxPoint2D result;
9257 void *argp1 = 0 ;
9258 int res1 = 0 ;
9259 PyObject *swig_obj[1] ;
9260
9261 if (!args) SWIG_fail;
9262 swig_obj[0] = args;
9263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9264 if (!SWIG_IsOK(res1)) {
9265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetPosition" "', expected argument " "1"" of type '" "wxRect2D *""'");
9266 }
9267 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9268 {
9269 result = (arg1)->GetPosition();
9270 if (PyErr_Occurred()) SWIG_fail;
9271 }
9272 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9273 return resultobj;
9274 fail:
9275 return NULL;
9276 }
9277
9278
9279 SWIGINTERN PyObject *_wrap_Rect2D_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9280 PyObject *resultobj = 0;
9281 wxRect2D *arg1 = (wxRect2D *) 0 ;
9282 wxSize result;
9283 void *argp1 = 0 ;
9284 int res1 = 0 ;
9285 PyObject *swig_obj[1] ;
9286
9287 if (!args) SWIG_fail;
9288 swig_obj[0] = args;
9289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9290 if (!SWIG_IsOK(res1)) {
9291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetSize" "', expected argument " "1"" of type '" "wxRect2D *""'");
9292 }
9293 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9294 {
9295 result = (arg1)->GetSize();
9296 if (PyErr_Occurred()) SWIG_fail;
9297 }
9298 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
9299 return resultobj;
9300 fail:
9301 return NULL;
9302 }
9303
9304
9305 SWIGINTERN PyObject *_wrap_Rect2D_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9306 PyObject *resultobj = 0;
9307 wxRect2D *arg1 = (wxRect2D *) 0 ;
9308 wxDouble result;
9309 void *argp1 = 0 ;
9310 int res1 = 0 ;
9311 PyObject *swig_obj[1] ;
9312
9313 if (!args) SWIG_fail;
9314 swig_obj[0] = args;
9315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9316 if (!SWIG_IsOK(res1)) {
9317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeft" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9318 }
9319 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9320 {
9321 result = ((wxRect2D const *)arg1)->GetLeft();
9322 if (PyErr_Occurred()) SWIG_fail;
9323 }
9324 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9325 return resultobj;
9326 fail:
9327 return NULL;
9328 }
9329
9330
9331 SWIGINTERN PyObject *_wrap_Rect2D_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9332 PyObject *resultobj = 0;
9333 wxRect2D *arg1 = (wxRect2D *) 0 ;
9334 wxDouble arg2 ;
9335 void *argp1 = 0 ;
9336 int res1 = 0 ;
9337 void *argp2 ;
9338 int res2 = 0 ;
9339 PyObject * obj0 = 0 ;
9340 PyObject * obj1 = 0 ;
9341 char * kwnames[] = {
9342 (char *) "self",(char *) "n", NULL
9343 };
9344
9345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
9346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9347 if (!SWIG_IsOK(res1)) {
9348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeft" "', expected argument " "1"" of type '" "wxRect2D *""'");
9349 }
9350 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9351 {
9352 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9353 if (!SWIG_IsOK(res2)) {
9354 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9355 }
9356 if (!argp2) {
9357 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9358 } else {
9359 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9360 arg2 = *temp;
9361 if (SWIG_IsNewObj(res2)) delete temp;
9362 }
9363 }
9364 {
9365 (arg1)->SetLeft(arg2);
9366 if (PyErr_Occurred()) SWIG_fail;
9367 }
9368 resultobj = SWIG_Py_Void();
9369 return resultobj;
9370 fail:
9371 return NULL;
9372 }
9373
9374
9375 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9376 PyObject *resultobj = 0;
9377 wxRect2D *arg1 = (wxRect2D *) 0 ;
9378 wxDouble arg2 ;
9379 void *argp1 = 0 ;
9380 int res1 = 0 ;
9381 void *argp2 ;
9382 int res2 = 0 ;
9383 PyObject * obj0 = 0 ;
9384 PyObject * obj1 = 0 ;
9385 char * kwnames[] = {
9386 (char *) "self",(char *) "n", NULL
9387 };
9388
9389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTo",kwnames,&obj0,&obj1)) SWIG_fail;
9390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9391 if (!SWIG_IsOK(res1)) {
9392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9393 }
9394 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9395 {
9396 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9397 if (!SWIG_IsOK(res2)) {
9398 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9399 }
9400 if (!argp2) {
9401 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9402 } else {
9403 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9404 arg2 = *temp;
9405 if (SWIG_IsNewObj(res2)) delete temp;
9406 }
9407 }
9408 {
9409 (arg1)->MoveLeftTo(arg2);
9410 if (PyErr_Occurred()) SWIG_fail;
9411 }
9412 resultobj = SWIG_Py_Void();
9413 return resultobj;
9414 fail:
9415 return NULL;
9416 }
9417
9418
9419 SWIGINTERN PyObject *_wrap_Rect2D_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9420 PyObject *resultobj = 0;
9421 wxRect2D *arg1 = (wxRect2D *) 0 ;
9422 wxDouble result;
9423 void *argp1 = 0 ;
9424 int res1 = 0 ;
9425 PyObject *swig_obj[1] ;
9426
9427 if (!args) SWIG_fail;
9428 swig_obj[0] = args;
9429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9430 if (!SWIG_IsOK(res1)) {
9431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9432 }
9433 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9434 {
9435 result = ((wxRect2D const *)arg1)->GetTop();
9436 if (PyErr_Occurred()) SWIG_fail;
9437 }
9438 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9439 return resultobj;
9440 fail:
9441 return NULL;
9442 }
9443
9444
9445 SWIGINTERN PyObject *_wrap_Rect2D_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9446 PyObject *resultobj = 0;
9447 wxRect2D *arg1 = (wxRect2D *) 0 ;
9448 wxDouble arg2 ;
9449 void *argp1 = 0 ;
9450 int res1 = 0 ;
9451 void *argp2 ;
9452 int res2 = 0 ;
9453 PyObject * obj0 = 0 ;
9454 PyObject * obj1 = 0 ;
9455 char * kwnames[] = {
9456 (char *) "self",(char *) "n", NULL
9457 };
9458
9459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
9460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9461 if (!SWIG_IsOK(res1)) {
9462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9463 }
9464 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9465 {
9466 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9467 if (!SWIG_IsOK(res2)) {
9468 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9469 }
9470 if (!argp2) {
9471 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9472 } else {
9473 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9474 arg2 = *temp;
9475 if (SWIG_IsNewObj(res2)) delete temp;
9476 }
9477 }
9478 {
9479 (arg1)->SetTop(arg2);
9480 if (PyErr_Occurred()) SWIG_fail;
9481 }
9482 resultobj = SWIG_Py_Void();
9483 return resultobj;
9484 fail:
9485 return NULL;
9486 }
9487
9488
9489 SWIGINTERN PyObject *_wrap_Rect2D_MoveTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9490 PyObject *resultobj = 0;
9491 wxRect2D *arg1 = (wxRect2D *) 0 ;
9492 wxDouble arg2 ;
9493 void *argp1 = 0 ;
9494 int res1 = 0 ;
9495 void *argp2 ;
9496 int res2 = 0 ;
9497 PyObject * obj0 = 0 ;
9498 PyObject * obj1 = 0 ;
9499 char * kwnames[] = {
9500 (char *) "self",(char *) "n", NULL
9501 };
9502
9503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9505 if (!SWIG_IsOK(res1)) {
9506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9507 }
9508 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9509 {
9510 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9511 if (!SWIG_IsOK(res2)) {
9512 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9513 }
9514 if (!argp2) {
9515 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9516 } else {
9517 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9518 arg2 = *temp;
9519 if (SWIG_IsNewObj(res2)) delete temp;
9520 }
9521 }
9522 {
9523 (arg1)->MoveTopTo(arg2);
9524 if (PyErr_Occurred()) SWIG_fail;
9525 }
9526 resultobj = SWIG_Py_Void();
9527 return resultobj;
9528 fail:
9529 return NULL;
9530 }
9531
9532
9533 SWIGINTERN PyObject *_wrap_Rect2D_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9534 PyObject *resultobj = 0;
9535 wxRect2D *arg1 = (wxRect2D *) 0 ;
9536 wxDouble result;
9537 void *argp1 = 0 ;
9538 int res1 = 0 ;
9539 PyObject *swig_obj[1] ;
9540
9541 if (!args) SWIG_fail;
9542 swig_obj[0] = args;
9543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9544 if (!SWIG_IsOK(res1)) {
9545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9546 }
9547 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9548 {
9549 result = ((wxRect2D const *)arg1)->GetBottom();
9550 if (PyErr_Occurred()) SWIG_fail;
9551 }
9552 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9553 return resultobj;
9554 fail:
9555 return NULL;
9556 }
9557
9558
9559 SWIGINTERN PyObject *_wrap_Rect2D_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9560 PyObject *resultobj = 0;
9561 wxRect2D *arg1 = (wxRect2D *) 0 ;
9562 wxDouble arg2 ;
9563 void *argp1 = 0 ;
9564 int res1 = 0 ;
9565 void *argp2 ;
9566 int res2 = 0 ;
9567 PyObject * obj0 = 0 ;
9568 PyObject * obj1 = 0 ;
9569 char * kwnames[] = {
9570 (char *) "self",(char *) "n", NULL
9571 };
9572
9573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9575 if (!SWIG_IsOK(res1)) {
9576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9577 }
9578 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9579 {
9580 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9581 if (!SWIG_IsOK(res2)) {
9582 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9583 }
9584 if (!argp2) {
9585 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9586 } else {
9587 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9588 arg2 = *temp;
9589 if (SWIG_IsNewObj(res2)) delete temp;
9590 }
9591 }
9592 {
9593 (arg1)->SetBottom(arg2);
9594 if (PyErr_Occurred()) SWIG_fail;
9595 }
9596 resultobj = SWIG_Py_Void();
9597 return resultobj;
9598 fail:
9599 return NULL;
9600 }
9601
9602
9603 SWIGINTERN PyObject *_wrap_Rect2D_MoveBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9604 PyObject *resultobj = 0;
9605 wxRect2D *arg1 = (wxRect2D *) 0 ;
9606 wxDouble arg2 ;
9607 void *argp1 = 0 ;
9608 int res1 = 0 ;
9609 void *argp2 ;
9610 int res2 = 0 ;
9611 PyObject * obj0 = 0 ;
9612 PyObject * obj1 = 0 ;
9613 char * kwnames[] = {
9614 (char *) "self",(char *) "n", NULL
9615 };
9616
9617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9619 if (!SWIG_IsOK(res1)) {
9620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9621 }
9622 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9623 {
9624 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9625 if (!SWIG_IsOK(res2)) {
9626 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9627 }
9628 if (!argp2) {
9629 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9630 } else {
9631 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9632 arg2 = *temp;
9633 if (SWIG_IsNewObj(res2)) delete temp;
9634 }
9635 }
9636 {
9637 (arg1)->MoveBottomTo(arg2);
9638 if (PyErr_Occurred()) SWIG_fail;
9639 }
9640 resultobj = SWIG_Py_Void();
9641 return resultobj;
9642 fail:
9643 return NULL;
9644 }
9645
9646
9647 SWIGINTERN PyObject *_wrap_Rect2D_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9648 PyObject *resultobj = 0;
9649 wxRect2D *arg1 = (wxRect2D *) 0 ;
9650 wxDouble result;
9651 void *argp1 = 0 ;
9652 int res1 = 0 ;
9653 PyObject *swig_obj[1] ;
9654
9655 if (!args) SWIG_fail;
9656 swig_obj[0] = args;
9657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9658 if (!SWIG_IsOK(res1)) {
9659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRight" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9660 }
9661 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9662 {
9663 result = ((wxRect2D const *)arg1)->GetRight();
9664 if (PyErr_Occurred()) SWIG_fail;
9665 }
9666 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9667 return resultobj;
9668 fail:
9669 return NULL;
9670 }
9671
9672
9673 SWIGINTERN PyObject *_wrap_Rect2D_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9674 PyObject *resultobj = 0;
9675 wxRect2D *arg1 = (wxRect2D *) 0 ;
9676 wxDouble arg2 ;
9677 void *argp1 = 0 ;
9678 int res1 = 0 ;
9679 void *argp2 ;
9680 int res2 = 0 ;
9681 PyObject * obj0 = 0 ;
9682 PyObject * obj1 = 0 ;
9683 char * kwnames[] = {
9684 (char *) "self",(char *) "n", NULL
9685 };
9686
9687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
9688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9689 if (!SWIG_IsOK(res1)) {
9690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRight" "', expected argument " "1"" of type '" "wxRect2D *""'");
9691 }
9692 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9693 {
9694 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9695 if (!SWIG_IsOK(res2)) {
9696 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9697 }
9698 if (!argp2) {
9699 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9700 } else {
9701 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9702 arg2 = *temp;
9703 if (SWIG_IsNewObj(res2)) delete temp;
9704 }
9705 }
9706 {
9707 (arg1)->SetRight(arg2);
9708 if (PyErr_Occurred()) SWIG_fail;
9709 }
9710 resultobj = SWIG_Py_Void();
9711 return resultobj;
9712 fail:
9713 return NULL;
9714 }
9715
9716
9717 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9718 PyObject *resultobj = 0;
9719 wxRect2D *arg1 = (wxRect2D *) 0 ;
9720 wxDouble arg2 ;
9721 void *argp1 = 0 ;
9722 int res1 = 0 ;
9723 void *argp2 ;
9724 int res2 = 0 ;
9725 PyObject * obj0 = 0 ;
9726 PyObject * obj1 = 0 ;
9727 char * kwnames[] = {
9728 (char *) "self",(char *) "n", NULL
9729 };
9730
9731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTo",kwnames,&obj0,&obj1)) SWIG_fail;
9732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9733 if (!SWIG_IsOK(res1)) {
9734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9735 }
9736 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9737 {
9738 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9739 if (!SWIG_IsOK(res2)) {
9740 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9741 }
9742 if (!argp2) {
9743 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9744 } else {
9745 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9746 arg2 = *temp;
9747 if (SWIG_IsNewObj(res2)) delete temp;
9748 }
9749 }
9750 {
9751 (arg1)->MoveRightTo(arg2);
9752 if (PyErr_Occurred()) SWIG_fail;
9753 }
9754 resultobj = SWIG_Py_Void();
9755 return resultobj;
9756 fail:
9757 return NULL;
9758 }
9759
9760
9761 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9762 PyObject *resultobj = 0;
9763 wxRect2D *arg1 = (wxRect2D *) 0 ;
9764 wxPoint2D result;
9765 void *argp1 = 0 ;
9766 int res1 = 0 ;
9767 PyObject *swig_obj[1] ;
9768
9769 if (!args) SWIG_fail;
9770 swig_obj[0] = args;
9771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9772 if (!SWIG_IsOK(res1)) {
9773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9774 }
9775 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9776 {
9777 result = ((wxRect2D const *)arg1)->GetLeftTop();
9778 if (PyErr_Occurred()) SWIG_fail;
9779 }
9780 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9781 return resultobj;
9782 fail:
9783 return NULL;
9784 }
9785
9786
9787 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9788 PyObject *resultobj = 0;
9789 wxRect2D *arg1 = (wxRect2D *) 0 ;
9790 wxPoint2D *arg2 = 0 ;
9791 void *argp1 = 0 ;
9792 int res1 = 0 ;
9793 wxPoint2D temp2 ;
9794 PyObject * obj0 = 0 ;
9795 PyObject * obj1 = 0 ;
9796 char * kwnames[] = {
9797 (char *) "self",(char *) "pt", NULL
9798 };
9799
9800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftTop",kwnames,&obj0,&obj1)) SWIG_fail;
9801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9802 if (!SWIG_IsOK(res1)) {
9803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9804 }
9805 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9806 {
9807 arg2 = &temp2;
9808 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9809 }
9810 {
9811 (arg1)->SetLeftTop((wxPoint2D const &)*arg2);
9812 if (PyErr_Occurred()) SWIG_fail;
9813 }
9814 resultobj = SWIG_Py_Void();
9815 return resultobj;
9816 fail:
9817 return NULL;
9818 }
9819
9820
9821 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9822 PyObject *resultobj = 0;
9823 wxRect2D *arg1 = (wxRect2D *) 0 ;
9824 wxPoint2D *arg2 = 0 ;
9825 void *argp1 = 0 ;
9826 int res1 = 0 ;
9827 wxPoint2D temp2 ;
9828 PyObject * obj0 = 0 ;
9829 PyObject * obj1 = 0 ;
9830 char * kwnames[] = {
9831 (char *) "self",(char *) "pt", NULL
9832 };
9833
9834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9836 if (!SWIG_IsOK(res1)) {
9837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9838 }
9839 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9840 {
9841 arg2 = &temp2;
9842 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9843 }
9844 {
9845 (arg1)->MoveLeftTopTo((wxPoint2D const &)*arg2);
9846 if (PyErr_Occurred()) SWIG_fail;
9847 }
9848 resultobj = SWIG_Py_Void();
9849 return resultobj;
9850 fail:
9851 return NULL;
9852 }
9853
9854
9855 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9856 PyObject *resultobj = 0;
9857 wxRect2D *arg1 = (wxRect2D *) 0 ;
9858 wxPoint2D result;
9859 void *argp1 = 0 ;
9860 int res1 = 0 ;
9861 PyObject *swig_obj[1] ;
9862
9863 if (!args) SWIG_fail;
9864 swig_obj[0] = args;
9865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9866 if (!SWIG_IsOK(res1)) {
9867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9868 }
9869 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9870 {
9871 result = ((wxRect2D const *)arg1)->GetLeftBottom();
9872 if (PyErr_Occurred()) SWIG_fail;
9873 }
9874 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9875 return resultobj;
9876 fail:
9877 return NULL;
9878 }
9879
9880
9881 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9882 PyObject *resultobj = 0;
9883 wxRect2D *arg1 = (wxRect2D *) 0 ;
9884 wxPoint2D *arg2 = 0 ;
9885 void *argp1 = 0 ;
9886 int res1 = 0 ;
9887 wxPoint2D temp2 ;
9888 PyObject * obj0 = 0 ;
9889 PyObject * obj1 = 0 ;
9890 char * kwnames[] = {
9891 (char *) "self",(char *) "pt", NULL
9892 };
9893
9894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9896 if (!SWIG_IsOK(res1)) {
9897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9898 }
9899 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9900 {
9901 arg2 = &temp2;
9902 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9903 }
9904 {
9905 (arg1)->SetLeftBottom((wxPoint2D const &)*arg2);
9906 if (PyErr_Occurred()) SWIG_fail;
9907 }
9908 resultobj = SWIG_Py_Void();
9909 return resultobj;
9910 fail:
9911 return NULL;
9912 }
9913
9914
9915 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9916 PyObject *resultobj = 0;
9917 wxRect2D *arg1 = (wxRect2D *) 0 ;
9918 wxPoint2D *arg2 = 0 ;
9919 void *argp1 = 0 ;
9920 int res1 = 0 ;
9921 wxPoint2D temp2 ;
9922 PyObject * obj0 = 0 ;
9923 PyObject * obj1 = 0 ;
9924 char * kwnames[] = {
9925 (char *) "self",(char *) "pt", NULL
9926 };
9927
9928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9930 if (!SWIG_IsOK(res1)) {
9931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9932 }
9933 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9934 {
9935 arg2 = &temp2;
9936 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9937 }
9938 {
9939 (arg1)->MoveLeftBottomTo((wxPoint2D const &)*arg2);
9940 if (PyErr_Occurred()) SWIG_fail;
9941 }
9942 resultobj = SWIG_Py_Void();
9943 return resultobj;
9944 fail:
9945 return NULL;
9946 }
9947
9948
9949 SWIGINTERN PyObject *_wrap_Rect2D_GetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9950 PyObject *resultobj = 0;
9951 wxRect2D *arg1 = (wxRect2D *) 0 ;
9952 wxPoint2D result;
9953 void *argp1 = 0 ;
9954 int res1 = 0 ;
9955 PyObject *swig_obj[1] ;
9956
9957 if (!args) SWIG_fail;
9958 swig_obj[0] = args;
9959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9960 if (!SWIG_IsOK(res1)) {
9961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9962 }
9963 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9964 {
9965 result = ((wxRect2D const *)arg1)->GetRightTop();
9966 if (PyErr_Occurred()) SWIG_fail;
9967 }
9968 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9969 return resultobj;
9970 fail:
9971 return NULL;
9972 }
9973
9974
9975 SWIGINTERN PyObject *_wrap_Rect2D_SetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9976 PyObject *resultobj = 0;
9977 wxRect2D *arg1 = (wxRect2D *) 0 ;
9978 wxPoint2D *arg2 = 0 ;
9979 void *argp1 = 0 ;
9980 int res1 = 0 ;
9981 wxPoint2D temp2 ;
9982 PyObject * obj0 = 0 ;
9983 PyObject * obj1 = 0 ;
9984 char * kwnames[] = {
9985 (char *) "self",(char *) "pt", NULL
9986 };
9987
9988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightTop",kwnames,&obj0,&obj1)) SWIG_fail;
9989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9990 if (!SWIG_IsOK(res1)) {
9991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9992 }
9993 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9994 {
9995 arg2 = &temp2;
9996 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9997 }
9998 {
9999 (arg1)->SetRightTop((wxPoint2D const &)*arg2);
10000 if (PyErr_Occurred()) SWIG_fail;
10001 }
10002 resultobj = SWIG_Py_Void();
10003 return resultobj;
10004 fail:
10005 return NULL;
10006 }
10007
10008
10009 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10010 PyObject *resultobj = 0;
10011 wxRect2D *arg1 = (wxRect2D *) 0 ;
10012 wxPoint2D *arg2 = 0 ;
10013 void *argp1 = 0 ;
10014 int res1 = 0 ;
10015 wxPoint2D temp2 ;
10016 PyObject * obj0 = 0 ;
10017 PyObject * obj1 = 0 ;
10018 char * kwnames[] = {
10019 (char *) "self",(char *) "pt", NULL
10020 };
10021
10022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
10023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10024 if (!SWIG_IsOK(res1)) {
10025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10026 }
10027 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10028 {
10029 arg2 = &temp2;
10030 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10031 }
10032 {
10033 (arg1)->MoveRightTopTo((wxPoint2D const &)*arg2);
10034 if (PyErr_Occurred()) SWIG_fail;
10035 }
10036 resultobj = SWIG_Py_Void();
10037 return resultobj;
10038 fail:
10039 return NULL;
10040 }
10041
10042
10043 SWIGINTERN PyObject *_wrap_Rect2D_GetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10044 PyObject *resultobj = 0;
10045 wxRect2D *arg1 = (wxRect2D *) 0 ;
10046 wxPoint2D result;
10047 void *argp1 = 0 ;
10048 int res1 = 0 ;
10049 PyObject *swig_obj[1] ;
10050
10051 if (!args) SWIG_fail;
10052 swig_obj[0] = args;
10053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10054 if (!SWIG_IsOK(res1)) {
10055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10056 }
10057 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10058 {
10059 result = ((wxRect2D const *)arg1)->GetRightBottom();
10060 if (PyErr_Occurred()) SWIG_fail;
10061 }
10062 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10063 return resultobj;
10064 fail:
10065 return NULL;
10066 }
10067
10068
10069 SWIGINTERN PyObject *_wrap_Rect2D_SetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10070 PyObject *resultobj = 0;
10071 wxRect2D *arg1 = (wxRect2D *) 0 ;
10072 wxPoint2D *arg2 = 0 ;
10073 void *argp1 = 0 ;
10074 int res1 = 0 ;
10075 wxPoint2D temp2 ;
10076 PyObject * obj0 = 0 ;
10077 PyObject * obj1 = 0 ;
10078 char * kwnames[] = {
10079 (char *) "self",(char *) "pt", NULL
10080 };
10081
10082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightBottom",kwnames,&obj0,&obj1)) SWIG_fail;
10083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10084 if (!SWIG_IsOK(res1)) {
10085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
10086 }
10087 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10088 {
10089 arg2 = &temp2;
10090 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10091 }
10092 {
10093 (arg1)->SetRightBottom((wxPoint2D const &)*arg2);
10094 if (PyErr_Occurred()) SWIG_fail;
10095 }
10096 resultobj = SWIG_Py_Void();
10097 return resultobj;
10098 fail:
10099 return NULL;
10100 }
10101
10102
10103 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10104 PyObject *resultobj = 0;
10105 wxRect2D *arg1 = (wxRect2D *) 0 ;
10106 wxPoint2D *arg2 = 0 ;
10107 void *argp1 = 0 ;
10108 int res1 = 0 ;
10109 wxPoint2D temp2 ;
10110 PyObject * obj0 = 0 ;
10111 PyObject * obj1 = 0 ;
10112 char * kwnames[] = {
10113 (char *) "self",(char *) "pt", NULL
10114 };
10115
10116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
10117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10118 if (!SWIG_IsOK(res1)) {
10119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10120 }
10121 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10122 {
10123 arg2 = &temp2;
10124 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10125 }
10126 {
10127 (arg1)->MoveRightBottomTo((wxPoint2D const &)*arg2);
10128 if (PyErr_Occurred()) SWIG_fail;
10129 }
10130 resultobj = SWIG_Py_Void();
10131 return resultobj;
10132 fail:
10133 return NULL;
10134 }
10135
10136
10137 SWIGINTERN PyObject *_wrap_Rect2D_GetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10138 PyObject *resultobj = 0;
10139 wxRect2D *arg1 = (wxRect2D *) 0 ;
10140 wxPoint2D result;
10141 void *argp1 = 0 ;
10142 int res1 = 0 ;
10143 PyObject *swig_obj[1] ;
10144
10145 if (!args) SWIG_fail;
10146 swig_obj[0] = args;
10147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10148 if (!SWIG_IsOK(res1)) {
10149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetCentre" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10150 }
10151 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10152 {
10153 result = ((wxRect2D const *)arg1)->GetCentre();
10154 if (PyErr_Occurred()) SWIG_fail;
10155 }
10156 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10157 return resultobj;
10158 fail:
10159 return NULL;
10160 }
10161
10162
10163 SWIGINTERN PyObject *_wrap_Rect2D_SetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10164 PyObject *resultobj = 0;
10165 wxRect2D *arg1 = (wxRect2D *) 0 ;
10166 wxPoint2D *arg2 = 0 ;
10167 void *argp1 = 0 ;
10168 int res1 = 0 ;
10169 wxPoint2D temp2 ;
10170 PyObject * obj0 = 0 ;
10171 PyObject * obj1 = 0 ;
10172 char * kwnames[] = {
10173 (char *) "self",(char *) "pt", NULL
10174 };
10175
10176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetCentre",kwnames,&obj0,&obj1)) SWIG_fail;
10177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10178 if (!SWIG_IsOK(res1)) {
10179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetCentre" "', expected argument " "1"" of type '" "wxRect2D *""'");
10180 }
10181 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10182 {
10183 arg2 = &temp2;
10184 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10185 }
10186 {
10187 (arg1)->SetCentre((wxPoint2D const &)*arg2);
10188 if (PyErr_Occurred()) SWIG_fail;
10189 }
10190 resultobj = SWIG_Py_Void();
10191 return resultobj;
10192 fail:
10193 return NULL;
10194 }
10195
10196
10197 SWIGINTERN PyObject *_wrap_Rect2D_MoveCentreTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10198 PyObject *resultobj = 0;
10199 wxRect2D *arg1 = (wxRect2D *) 0 ;
10200 wxPoint2D *arg2 = 0 ;
10201 void *argp1 = 0 ;
10202 int res1 = 0 ;
10203 wxPoint2D temp2 ;
10204 PyObject * obj0 = 0 ;
10205 PyObject * obj1 = 0 ;
10206 char * kwnames[] = {
10207 (char *) "self",(char *) "pt", NULL
10208 };
10209
10210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveCentreTo",kwnames,&obj0,&obj1)) SWIG_fail;
10211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10212 if (!SWIG_IsOK(res1)) {
10213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveCentreTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10214 }
10215 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10216 {
10217 arg2 = &temp2;
10218 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10219 }
10220 {
10221 (arg1)->MoveCentreTo((wxPoint2D const &)*arg2);
10222 if (PyErr_Occurred()) SWIG_fail;
10223 }
10224 resultobj = SWIG_Py_Void();
10225 return resultobj;
10226 fail:
10227 return NULL;
10228 }
10229
10230
10231 SWIGINTERN PyObject *_wrap_Rect2D_GetOutcode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10232 PyObject *resultobj = 0;
10233 wxRect2D *arg1 = (wxRect2D *) 0 ;
10234 wxPoint2D *arg2 = 0 ;
10235 wxOutCode result;
10236 void *argp1 = 0 ;
10237 int res1 = 0 ;
10238 wxPoint2D temp2 ;
10239 PyObject * obj0 = 0 ;
10240 PyObject * obj1 = 0 ;
10241 char * kwnames[] = {
10242 (char *) "self",(char *) "pt", NULL
10243 };
10244
10245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_GetOutcode",kwnames,&obj0,&obj1)) SWIG_fail;
10246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10247 if (!SWIG_IsOK(res1)) {
10248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetOutcode" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10249 }
10250 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10251 {
10252 arg2 = &temp2;
10253 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10254 }
10255 {
10256 result = (wxOutCode)((wxRect2D const *)arg1)->GetOutcode((wxPoint2D const &)*arg2);
10257 if (PyErr_Occurred()) SWIG_fail;
10258 }
10259 resultobj = SWIG_From_int(static_cast< int >(result));
10260 return resultobj;
10261 fail:
10262 return NULL;
10263 }
10264
10265
10266 SWIGINTERN PyObject *_wrap_Rect2D_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10267 PyObject *resultobj = 0;
10268 wxRect2D *arg1 = (wxRect2D *) 0 ;
10269 wxPoint2D *arg2 = 0 ;
10270 bool result;
10271 void *argp1 = 0 ;
10272 int res1 = 0 ;
10273 wxPoint2D temp2 ;
10274 PyObject * obj0 = 0 ;
10275 PyObject * obj1 = 0 ;
10276 char * kwnames[] = {
10277 (char *) "self",(char *) "pt", NULL
10278 };
10279
10280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
10281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10282 if (!SWIG_IsOK(res1)) {
10283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Contains" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10284 }
10285 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10286 {
10287 arg2 = &temp2;
10288 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10289 }
10290 {
10291 result = (bool)((wxRect2D const *)arg1)->Contains((wxPoint2D const &)*arg2);
10292 if (PyErr_Occurred()) SWIG_fail;
10293 }
10294 {
10295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10296 }
10297 return resultobj;
10298 fail:
10299 return NULL;
10300 }
10301
10302
10303 SWIGINTERN PyObject *_wrap_Rect2D_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10304 PyObject *resultobj = 0;
10305 wxRect2D *arg1 = (wxRect2D *) 0 ;
10306 wxRect2D *arg2 = 0 ;
10307 bool result;
10308 void *argp1 = 0 ;
10309 int res1 = 0 ;
10310 wxRect2D temp2 ;
10311 PyObject * obj0 = 0 ;
10312 PyObject * obj1 = 0 ;
10313 char * kwnames[] = {
10314 (char *) "self",(char *) "rect", NULL
10315 };
10316
10317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
10318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10319 if (!SWIG_IsOK(res1)) {
10320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ContainsRect" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10321 }
10322 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10323 {
10324 arg2 = &temp2;
10325 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10326 }
10327 {
10328 result = (bool)((wxRect2D const *)arg1)->Contains((wxRect2D const &)*arg2);
10329 if (PyErr_Occurred()) SWIG_fail;
10330 }
10331 {
10332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10333 }
10334 return resultobj;
10335 fail:
10336 return NULL;
10337 }
10338
10339
10340 SWIGINTERN PyObject *_wrap_Rect2D_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10341 PyObject *resultobj = 0;
10342 wxRect2D *arg1 = (wxRect2D *) 0 ;
10343 bool result;
10344 void *argp1 = 0 ;
10345 int res1 = 0 ;
10346 PyObject *swig_obj[1] ;
10347
10348 if (!args) SWIG_fail;
10349 swig_obj[0] = args;
10350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10351 if (!SWIG_IsOK(res1)) {
10352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_IsEmpty" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10353 }
10354 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10355 {
10356 result = (bool)((wxRect2D const *)arg1)->IsEmpty();
10357 if (PyErr_Occurred()) SWIG_fail;
10358 }
10359 {
10360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10361 }
10362 return resultobj;
10363 fail:
10364 return NULL;
10365 }
10366
10367
10368 SWIGINTERN PyObject *_wrap_Rect2D_HaveEqualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10369 PyObject *resultobj = 0;
10370 wxRect2D *arg1 = (wxRect2D *) 0 ;
10371 wxRect2D *arg2 = 0 ;
10372 bool result;
10373 void *argp1 = 0 ;
10374 int res1 = 0 ;
10375 wxRect2D temp2 ;
10376 PyObject * obj0 = 0 ;
10377 PyObject * obj1 = 0 ;
10378 char * kwnames[] = {
10379 (char *) "self",(char *) "rect", NULL
10380 };
10381
10382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_HaveEqualSize",kwnames,&obj0,&obj1)) SWIG_fail;
10383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10384 if (!SWIG_IsOK(res1)) {
10385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_HaveEqualSize" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10386 }
10387 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10388 {
10389 arg2 = &temp2;
10390 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10391 }
10392 {
10393 result = (bool)((wxRect2D const *)arg1)->HaveEqualSize((wxRect2D const &)*arg2);
10394 if (PyErr_Occurred()) SWIG_fail;
10395 }
10396 {
10397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10398 }
10399 return resultobj;
10400 fail:
10401 return NULL;
10402 }
10403
10404
10405 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10406 PyObject *resultobj = 0;
10407 wxRect2D *arg1 = (wxRect2D *) 0 ;
10408 wxDouble arg2 ;
10409 wxDouble arg3 ;
10410 void *argp1 = 0 ;
10411 int res1 = 0 ;
10412 void *argp2 ;
10413 int res2 = 0 ;
10414 void *argp3 ;
10415 int res3 = 0 ;
10416
10417 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10419 if (!SWIG_IsOK(res1)) {
10420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10421 }
10422 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10423 {
10424 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10425 if (!SWIG_IsOK(res2)) {
10426 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10427 }
10428 if (!argp2) {
10429 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10430 } else {
10431 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10432 arg2 = *temp;
10433 if (SWIG_IsNewObj(res2)) delete temp;
10434 }
10435 }
10436 {
10437 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10438 if (!SWIG_IsOK(res3)) {
10439 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10440 }
10441 if (!argp3) {
10442 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10443 } else {
10444 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10445 arg3 = *temp;
10446 if (SWIG_IsNewObj(res3)) delete temp;
10447 }
10448 }
10449 {
10450 (arg1)->Inset(arg2,arg3);
10451 if (PyErr_Occurred()) SWIG_fail;
10452 }
10453 resultobj = SWIG_Py_Void();
10454 return resultobj;
10455 fail:
10456 return NULL;
10457 }
10458
10459
10460 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10461 PyObject *resultobj = 0;
10462 wxRect2D *arg1 = (wxRect2D *) 0 ;
10463 wxDouble arg2 ;
10464 wxDouble arg3 ;
10465 wxDouble arg4 ;
10466 wxDouble arg5 ;
10467 void *argp1 = 0 ;
10468 int res1 = 0 ;
10469 void *argp2 ;
10470 int res2 = 0 ;
10471 void *argp3 ;
10472 int res3 = 0 ;
10473 void *argp4 ;
10474 int res4 = 0 ;
10475 void *argp5 ;
10476 int res5 = 0 ;
10477
10478 if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
10479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10480 if (!SWIG_IsOK(res1)) {
10481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10482 }
10483 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10484 {
10485 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10486 if (!SWIG_IsOK(res2)) {
10487 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10488 }
10489 if (!argp2) {
10490 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10491 } else {
10492 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10493 arg2 = *temp;
10494 if (SWIG_IsNewObj(res2)) delete temp;
10495 }
10496 }
10497 {
10498 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10499 if (!SWIG_IsOK(res3)) {
10500 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10501 }
10502 if (!argp3) {
10503 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10504 } else {
10505 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10506 arg3 = *temp;
10507 if (SWIG_IsNewObj(res3)) delete temp;
10508 }
10509 }
10510 {
10511 res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
10512 if (!SWIG_IsOK(res4)) {
10513 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10514 }
10515 if (!argp4) {
10516 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10517 } else {
10518 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
10519 arg4 = *temp;
10520 if (SWIG_IsNewObj(res4)) delete temp;
10521 }
10522 }
10523 {
10524 res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
10525 if (!SWIG_IsOK(res5)) {
10526 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10527 }
10528 if (!argp5) {
10529 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10530 } else {
10531 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
10532 arg5 = *temp;
10533 if (SWIG_IsNewObj(res5)) delete temp;
10534 }
10535 }
10536 {
10537 (arg1)->Inset(arg2,arg3,arg4,arg5);
10538 if (PyErr_Occurred()) SWIG_fail;
10539 }
10540 resultobj = SWIG_Py_Void();
10541 return resultobj;
10542 fail:
10543 return NULL;
10544 }
10545
10546
10547 SWIGINTERN PyObject *_wrap_Rect2D_Inset(PyObject *self, PyObject *args) {
10548 int argc;
10549 PyObject *argv[6];
10550
10551 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Inset",0,5,argv))) SWIG_fail;
10552 --argc;
10553 if (argc == 3) {
10554 return _wrap_Rect2D_Inset__SWIG_0(self, argc, argv);
10555 }
10556 if (argc == 5) {
10557 return _wrap_Rect2D_Inset__SWIG_1(self, argc, argv);
10558 }
10559
10560 fail:
10561 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Inset'");
10562 return NULL;
10563 }
10564
10565
10566 SWIGINTERN PyObject *_wrap_Rect2D_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10567 PyObject *resultobj = 0;
10568 wxRect2D *arg1 = (wxRect2D *) 0 ;
10569 wxPoint2D *arg2 = 0 ;
10570 void *argp1 = 0 ;
10571 int res1 = 0 ;
10572 wxPoint2D temp2 ;
10573 PyObject * obj0 = 0 ;
10574 PyObject * obj1 = 0 ;
10575 char * kwnames[] = {
10576 (char *) "self",(char *) "pt", NULL
10577 };
10578
10579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
10580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10581 if (!SWIG_IsOK(res1)) {
10582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Offset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10583 }
10584 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10585 {
10586 arg2 = &temp2;
10587 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10588 }
10589 {
10590 (arg1)->Offset((wxPoint2D const &)*arg2);
10591 if (PyErr_Occurred()) SWIG_fail;
10592 }
10593 resultobj = SWIG_Py_Void();
10594 return resultobj;
10595 fail:
10596 return NULL;
10597 }
10598
10599
10600 SWIGINTERN PyObject *_wrap_Rect2D_ConstrainTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10601 PyObject *resultobj = 0;
10602 wxRect2D *arg1 = (wxRect2D *) 0 ;
10603 wxRect2D *arg2 = 0 ;
10604 void *argp1 = 0 ;
10605 int res1 = 0 ;
10606 wxRect2D temp2 ;
10607 PyObject * obj0 = 0 ;
10608 PyObject * obj1 = 0 ;
10609 char * kwnames[] = {
10610 (char *) "self",(char *) "rect", NULL
10611 };
10612
10613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ConstrainTo",kwnames,&obj0,&obj1)) SWIG_fail;
10614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10615 if (!SWIG_IsOK(res1)) {
10616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ConstrainTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10617 }
10618 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10619 {
10620 arg2 = &temp2;
10621 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10622 }
10623 {
10624 (arg1)->ConstrainTo((wxRect2D const &)*arg2);
10625 if (PyErr_Occurred()) SWIG_fail;
10626 }
10627 resultobj = SWIG_Py_Void();
10628 return resultobj;
10629 fail:
10630 return NULL;
10631 }
10632
10633
10634 SWIGINTERN PyObject *_wrap_Rect2D_Interpolate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10635 PyObject *resultobj = 0;
10636 wxRect2D *arg1 = (wxRect2D *) 0 ;
10637 int arg2 ;
10638 int arg3 ;
10639 wxPoint2D result;
10640 void *argp1 = 0 ;
10641 int res1 = 0 ;
10642 int val2 ;
10643 int ecode2 = 0 ;
10644 int val3 ;
10645 int ecode3 = 0 ;
10646 PyObject * obj0 = 0 ;
10647 PyObject * obj1 = 0 ;
10648 PyObject * obj2 = 0 ;
10649 char * kwnames[] = {
10650 (char *) "self",(char *) "widthfactor",(char *) "heightfactor", NULL
10651 };
10652
10653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect2D_Interpolate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10655 if (!SWIG_IsOK(res1)) {
10656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Interpolate" "', expected argument " "1"" of type '" "wxRect2D *""'");
10657 }
10658 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10659 ecode2 = SWIG_AsVal_int(obj1, &val2);
10660 if (!SWIG_IsOK(ecode2)) {
10661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Interpolate" "', expected argument " "2"" of type '" "int""'");
10662 }
10663 arg2 = static_cast< int >(val2);
10664 ecode3 = SWIG_AsVal_int(obj2, &val3);
10665 if (!SWIG_IsOK(ecode3)) {
10666 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Interpolate" "', expected argument " "3"" of type '" "int""'");
10667 }
10668 arg3 = static_cast< int >(val3);
10669 {
10670 result = (arg1)->Interpolate(arg2,arg3);
10671 if (PyErr_Occurred()) SWIG_fail;
10672 }
10673 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10674 return resultobj;
10675 fail:
10676 return NULL;
10677 }
10678
10679
10680 SWIGINTERN PyObject *_wrap_Rect2D_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10681 PyObject *resultobj = 0;
10682 wxRect2D *arg1 = (wxRect2D *) 0 ;
10683 wxRect2D *arg2 = 0 ;
10684 void *argp1 = 0 ;
10685 int res1 = 0 ;
10686 wxRect2D temp2 ;
10687 PyObject * obj0 = 0 ;
10688 PyObject * obj1 = 0 ;
10689 char * kwnames[] = {
10690 (char *) "self",(char *) "otherRect", NULL
10691 };
10692
10693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
10694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10695 if (!SWIG_IsOK(res1)) {
10696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersect" "', expected argument " "1"" of type '" "wxRect2D *""'");
10697 }
10698 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10699 {
10700 arg2 = &temp2;
10701 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10702 }
10703 {
10704 (arg1)->Intersect((wxRect2D const &)*arg2);
10705 if (PyErr_Occurred()) SWIG_fail;
10706 }
10707 resultobj = SWIG_Py_Void();
10708 return resultobj;
10709 fail:
10710 return NULL;
10711 }
10712
10713
10714 SWIGINTERN PyObject *_wrap_Rect2D_CreateIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10715 PyObject *resultobj = 0;
10716 wxRect2D *arg1 = (wxRect2D *) 0 ;
10717 wxRect2D *arg2 = 0 ;
10718 wxRect2D result;
10719 void *argp1 = 0 ;
10720 int res1 = 0 ;
10721 wxRect2D temp2 ;
10722 PyObject * obj0 = 0 ;
10723 PyObject * obj1 = 0 ;
10724 char * kwnames[] = {
10725 (char *) "self",(char *) "otherRect", NULL
10726 };
10727
10728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateIntersection",kwnames,&obj0,&obj1)) SWIG_fail;
10729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10730 if (!SWIG_IsOK(res1)) {
10731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateIntersection" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10732 }
10733 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10734 {
10735 arg2 = &temp2;
10736 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10737 }
10738 {
10739 result = ((wxRect2D const *)arg1)->CreateIntersection((wxRect2D const &)*arg2);
10740 if (PyErr_Occurred()) SWIG_fail;
10741 }
10742 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10743 return resultobj;
10744 fail:
10745 return NULL;
10746 }
10747
10748
10749 SWIGINTERN PyObject *_wrap_Rect2D_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10750 PyObject *resultobj = 0;
10751 wxRect2D *arg1 = (wxRect2D *) 0 ;
10752 wxRect2D *arg2 = 0 ;
10753 bool result;
10754 void *argp1 = 0 ;
10755 int res1 = 0 ;
10756 wxRect2D temp2 ;
10757 PyObject * obj0 = 0 ;
10758 PyObject * obj1 = 0 ;
10759 char * kwnames[] = {
10760 (char *) "self",(char *) "rect", NULL
10761 };
10762
10763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
10764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10765 if (!SWIG_IsOK(res1)) {
10766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersects" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10767 }
10768 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10769 {
10770 arg2 = &temp2;
10771 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10772 }
10773 {
10774 result = (bool)((wxRect2D const *)arg1)->Intersects((wxRect2D const &)*arg2);
10775 if (PyErr_Occurred()) SWIG_fail;
10776 }
10777 {
10778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10779 }
10780 return resultobj;
10781 fail:
10782 return NULL;
10783 }
10784
10785
10786 SWIGINTERN PyObject *_wrap_Rect2D_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10787 PyObject *resultobj = 0;
10788 wxRect2D *arg1 = (wxRect2D *) 0 ;
10789 wxRect2D *arg2 = 0 ;
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_Union",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_Union" "', expected argument " "1"" of type '" "wxRect2D *""'");
10803 }
10804 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10805 {
10806 arg2 = &temp2;
10807 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10808 }
10809 {
10810 (arg1)->Union((wxRect2D const &)*arg2);
10811 if (PyErr_Occurred()) SWIG_fail;
10812 }
10813 resultobj = SWIG_Py_Void();
10814 return resultobj;
10815 fail:
10816 return NULL;
10817 }
10818
10819
10820 SWIGINTERN PyObject *_wrap_Rect2D_CreateUnion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10821 PyObject *resultobj = 0;
10822 wxRect2D *arg1 = (wxRect2D *) 0 ;
10823 wxRect2D *arg2 = 0 ;
10824 wxRect2D 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 *) "otherRect", NULL
10832 };
10833
10834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateUnion",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_CreateUnion" "', 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 = ((wxRect2D const *)arg1)->CreateUnion((wxRect2D const &)*arg2);
10846 if (PyErr_Occurred()) SWIG_fail;
10847 }
10848 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10849 return resultobj;
10850 fail:
10851 return NULL;
10852 }
10853
10854
10855 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10856 PyObject *resultobj = 0;
10857 wxRect2D *arg1 = (wxRect2D *) 0 ;
10858 wxDouble arg2 ;
10859 void *argp1 = 0 ;
10860 int res1 = 0 ;
10861 void *argp2 ;
10862 int res2 = 0 ;
10863
10864 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
10865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10866 if (!SWIG_IsOK(res1)) {
10867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10868 }
10869 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10870 {
10871 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10872 if (!SWIG_IsOK(res2)) {
10873 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10874 }
10875 if (!argp2) {
10876 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10877 } else {
10878 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10879 arg2 = *temp;
10880 if (SWIG_IsNewObj(res2)) delete temp;
10881 }
10882 }
10883 {
10884 (arg1)->Scale(arg2);
10885 if (PyErr_Occurred()) SWIG_fail;
10886 }
10887 resultobj = SWIG_Py_Void();
10888 return resultobj;
10889 fail:
10890 return NULL;
10891 }
10892
10893
10894 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10895 PyObject *resultobj = 0;
10896 wxRect2D *arg1 = (wxRect2D *) 0 ;
10897 int arg2 ;
10898 int arg3 ;
10899 void *argp1 = 0 ;
10900 int res1 = 0 ;
10901 int val2 ;
10902 int ecode2 = 0 ;
10903 int val3 ;
10904 int ecode3 = 0 ;
10905
10906 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10908 if (!SWIG_IsOK(res1)) {
10909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10910 }
10911 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10912 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10913 if (!SWIG_IsOK(ecode2)) {
10914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "int""'");
10915 }
10916 arg2 = static_cast< int >(val2);
10917 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10918 if (!SWIG_IsOK(ecode3)) {
10919 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Scale" "', expected argument " "3"" of type '" "int""'");
10920 }
10921 arg3 = static_cast< int >(val3);
10922 {
10923 (arg1)->Scale(arg2,arg3);
10924 if (PyErr_Occurred()) SWIG_fail;
10925 }
10926 resultobj = SWIG_Py_Void();
10927 return resultobj;
10928 fail:
10929 return NULL;
10930 }
10931
10932
10933 SWIGINTERN PyObject *_wrap_Rect2D_Scale(PyObject *self, PyObject *args) {
10934 int argc;
10935 PyObject *argv[4];
10936
10937 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Scale",0,3,argv))) SWIG_fail;
10938 --argc;
10939 if (argc == 2) {
10940 return _wrap_Rect2D_Scale__SWIG_0(self, argc, argv);
10941 }
10942 if (argc == 3) {
10943 return _wrap_Rect2D_Scale__SWIG_1(self, argc, argv);
10944 }
10945
10946 fail:
10947 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Scale'");
10948 return NULL;
10949 }
10950
10951
10952 SWIGINTERN PyObject *_wrap_Rect2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10953 PyObject *resultobj = 0;
10954 wxRect2D *arg1 = (wxRect2D *) 0 ;
10955 PyObject *arg2 = (PyObject *) 0 ;
10956 bool result;
10957 void *argp1 = 0 ;
10958 int res1 = 0 ;
10959 PyObject * obj0 = 0 ;
10960 PyObject * obj1 = 0 ;
10961 char * kwnames[] = {
10962 (char *) "self",(char *) "other", NULL
10963 };
10964
10965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10967 if (!SWIG_IsOK(res1)) {
10968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___eq__" "', expected argument " "1"" of type '" "wxRect2D *""'");
10969 }
10970 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10971 arg2 = obj1;
10972 {
10973 result = (bool)wxRect2D___eq__(arg1,arg2);
10974 if (PyErr_Occurred()) SWIG_fail;
10975 }
10976 {
10977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10978 }
10979 return resultobj;
10980 fail:
10981 return NULL;
10982 }
10983
10984
10985 SWIGINTERN PyObject *_wrap_Rect2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10986 PyObject *resultobj = 0;
10987 wxRect2D *arg1 = (wxRect2D *) 0 ;
10988 PyObject *arg2 = (PyObject *) 0 ;
10989 bool result;
10990 void *argp1 = 0 ;
10991 int res1 = 0 ;
10992 PyObject * obj0 = 0 ;
10993 PyObject * obj1 = 0 ;
10994 char * kwnames[] = {
10995 (char *) "self",(char *) "other", NULL
10996 };
10997
10998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11000 if (!SWIG_IsOK(res1)) {
11001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___ne__" "', expected argument " "1"" of type '" "wxRect2D *""'");
11002 }
11003 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11004 arg2 = obj1;
11005 {
11006 result = (bool)wxRect2D___ne__(arg1,arg2);
11007 if (PyErr_Occurred()) SWIG_fail;
11008 }
11009 {
11010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11011 }
11012 return resultobj;
11013 fail:
11014 return NULL;
11015 }
11016
11017
11018 SWIGINTERN PyObject *_wrap_Rect2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11019 PyObject *resultobj = 0;
11020 wxRect2D *arg1 = (wxRect2D *) 0 ;
11021 wxDouble arg2 ;
11022 void *argp1 = 0 ;
11023 int res1 = 0 ;
11024 void *argp2 ;
11025 int res2 = 0 ;
11026 PyObject *swig_obj[2] ;
11027
11028 if (!SWIG_Python_UnpackTuple(args,"Rect2D_x_set",2,2,swig_obj)) SWIG_fail;
11029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11030 if (!SWIG_IsOK(res1)) {
11031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11032 }
11033 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11034 {
11035 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11036 if (!SWIG_IsOK(res2)) {
11037 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11038 }
11039 if (!argp2) {
11040 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11041 } else {
11042 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11043 arg2 = *temp;
11044 if (SWIG_IsNewObj(res2)) delete temp;
11045 }
11046 }
11047 if (arg1) (arg1)->m_x = arg2;
11048
11049 resultobj = SWIG_Py_Void();
11050 return resultobj;
11051 fail:
11052 return NULL;
11053 }
11054
11055
11056 SWIGINTERN PyObject *_wrap_Rect2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11057 PyObject *resultobj = 0;
11058 wxRect2D *arg1 = (wxRect2D *) 0 ;
11059 wxDouble result;
11060 void *argp1 = 0 ;
11061 int res1 = 0 ;
11062 PyObject *swig_obj[1] ;
11063
11064 if (!args) SWIG_fail;
11065 swig_obj[0] = args;
11066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11067 if (!SWIG_IsOK(res1)) {
11068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11069 }
11070 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11071 result = ((arg1)->m_x);
11072 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11073 return resultobj;
11074 fail:
11075 return NULL;
11076 }
11077
11078
11079 SWIGINTERN PyObject *_wrap_Rect2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11080 PyObject *resultobj = 0;
11081 wxRect2D *arg1 = (wxRect2D *) 0 ;
11082 wxDouble arg2 ;
11083 void *argp1 = 0 ;
11084 int res1 = 0 ;
11085 void *argp2 ;
11086 int res2 = 0 ;
11087 PyObject *swig_obj[2] ;
11088
11089 if (!SWIG_Python_UnpackTuple(args,"Rect2D_y_set",2,2,swig_obj)) SWIG_fail;
11090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11091 if (!SWIG_IsOK(res1)) {
11092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11093 }
11094 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11095 {
11096 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11097 if (!SWIG_IsOK(res2)) {
11098 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11099 }
11100 if (!argp2) {
11101 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11102 } else {
11103 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11104 arg2 = *temp;
11105 if (SWIG_IsNewObj(res2)) delete temp;
11106 }
11107 }
11108 if (arg1) (arg1)->m_y = arg2;
11109
11110 resultobj = SWIG_Py_Void();
11111 return resultobj;
11112 fail:
11113 return NULL;
11114 }
11115
11116
11117 SWIGINTERN PyObject *_wrap_Rect2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11118 PyObject *resultobj = 0;
11119 wxRect2D *arg1 = (wxRect2D *) 0 ;
11120 wxDouble result;
11121 void *argp1 = 0 ;
11122 int res1 = 0 ;
11123 PyObject *swig_obj[1] ;
11124
11125 if (!args) SWIG_fail;
11126 swig_obj[0] = args;
11127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11128 if (!SWIG_IsOK(res1)) {
11129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11130 }
11131 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11132 result = ((arg1)->m_y);
11133 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11134 return resultobj;
11135 fail:
11136 return NULL;
11137 }
11138
11139
11140 SWIGINTERN PyObject *_wrap_Rect2D_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11141 PyObject *resultobj = 0;
11142 wxRect2D *arg1 = (wxRect2D *) 0 ;
11143 wxDouble arg2 ;
11144 void *argp1 = 0 ;
11145 int res1 = 0 ;
11146 void *argp2 ;
11147 int res2 = 0 ;
11148 PyObject *swig_obj[2] ;
11149
11150 if (!SWIG_Python_UnpackTuple(args,"Rect2D_width_set",2,2,swig_obj)) SWIG_fail;
11151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11152 if (!SWIG_IsOK(res1)) {
11153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11154 }
11155 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11156 {
11157 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11158 if (!SWIG_IsOK(res2)) {
11159 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11160 }
11161 if (!argp2) {
11162 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11163 } else {
11164 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11165 arg2 = *temp;
11166 if (SWIG_IsNewObj(res2)) delete temp;
11167 }
11168 }
11169 if (arg1) (arg1)->m_width = arg2;
11170
11171 resultobj = SWIG_Py_Void();
11172 return resultobj;
11173 fail:
11174 return NULL;
11175 }
11176
11177
11178 SWIGINTERN PyObject *_wrap_Rect2D_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11179 PyObject *resultobj = 0;
11180 wxRect2D *arg1 = (wxRect2D *) 0 ;
11181 wxDouble result;
11182 void *argp1 = 0 ;
11183 int res1 = 0 ;
11184 PyObject *swig_obj[1] ;
11185
11186 if (!args) SWIG_fail;
11187 swig_obj[0] = args;
11188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11189 if (!SWIG_IsOK(res1)) {
11190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11191 }
11192 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11193 result = ((arg1)->m_width);
11194 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11195 return resultobj;
11196 fail:
11197 return NULL;
11198 }
11199
11200
11201 SWIGINTERN PyObject *_wrap_Rect2D_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11202 PyObject *resultobj = 0;
11203 wxRect2D *arg1 = (wxRect2D *) 0 ;
11204 wxDouble arg2 ;
11205 void *argp1 = 0 ;
11206 int res1 = 0 ;
11207 void *argp2 ;
11208 int res2 = 0 ;
11209 PyObject *swig_obj[2] ;
11210
11211 if (!SWIG_Python_UnpackTuple(args,"Rect2D_height_set",2,2,swig_obj)) SWIG_fail;
11212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11213 if (!SWIG_IsOK(res1)) {
11214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11215 }
11216 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11217 {
11218 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11219 if (!SWIG_IsOK(res2)) {
11220 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11221 }
11222 if (!argp2) {
11223 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11224 } else {
11225 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11226 arg2 = *temp;
11227 if (SWIG_IsNewObj(res2)) delete temp;
11228 }
11229 }
11230 if (arg1) (arg1)->m_height = arg2;
11231
11232 resultobj = SWIG_Py_Void();
11233 return resultobj;
11234 fail:
11235 return NULL;
11236 }
11237
11238
11239 SWIGINTERN PyObject *_wrap_Rect2D_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11240 PyObject *resultobj = 0;
11241 wxRect2D *arg1 = (wxRect2D *) 0 ;
11242 wxDouble result;
11243 void *argp1 = 0 ;
11244 int res1 = 0 ;
11245 PyObject *swig_obj[1] ;
11246
11247 if (!args) SWIG_fail;
11248 swig_obj[0] = args;
11249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11250 if (!SWIG_IsOK(res1)) {
11251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11252 }
11253 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11254 result = ((arg1)->m_height);
11255 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11256 return resultobj;
11257 fail:
11258 return NULL;
11259 }
11260
11261
11262 SWIGINTERN PyObject *_wrap_Rect2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11263 PyObject *resultobj = 0;
11264 wxRect2D *arg1 = (wxRect2D *) 0 ;
11265 wxDouble arg2 = (wxDouble) 0 ;
11266 wxDouble arg3 = (wxDouble) 0 ;
11267 wxDouble arg4 = (wxDouble) 0 ;
11268 wxDouble arg5 = (wxDouble) 0 ;
11269 void *argp1 = 0 ;
11270 int res1 = 0 ;
11271 void *argp2 ;
11272 int res2 = 0 ;
11273 void *argp3 ;
11274 int res3 = 0 ;
11275 void *argp4 ;
11276 int res4 = 0 ;
11277 void *argp5 ;
11278 int res5 = 0 ;
11279 PyObject * obj0 = 0 ;
11280 PyObject * obj1 = 0 ;
11281 PyObject * obj2 = 0 ;
11282 PyObject * obj3 = 0 ;
11283 PyObject * obj4 = 0 ;
11284 char * kwnames[] = {
11285 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
11286 };
11287
11288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect2D_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11290 if (!SWIG_IsOK(res1)) {
11291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11292 }
11293 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11294 if (obj1) {
11295 {
11296 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11297 if (!SWIG_IsOK(res2)) {
11298 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11299 }
11300 if (!argp2) {
11301 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11302 } else {
11303 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11304 arg2 = *temp;
11305 if (SWIG_IsNewObj(res2)) delete temp;
11306 }
11307 }
11308 }
11309 if (obj2) {
11310 {
11311 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
11312 if (!SWIG_IsOK(res3)) {
11313 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11314 }
11315 if (!argp3) {
11316 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11317 } else {
11318 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
11319 arg3 = *temp;
11320 if (SWIG_IsNewObj(res3)) delete temp;
11321 }
11322 }
11323 }
11324 if (obj3) {
11325 {
11326 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
11327 if (!SWIG_IsOK(res4)) {
11328 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11329 }
11330 if (!argp4) {
11331 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11332 } else {
11333 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
11334 arg4 = *temp;
11335 if (SWIG_IsNewObj(res4)) delete temp;
11336 }
11337 }
11338 }
11339 if (obj4) {
11340 {
11341 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
11342 if (!SWIG_IsOK(res5)) {
11343 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11344 }
11345 if (!argp5) {
11346 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11347 } else {
11348 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
11349 arg5 = *temp;
11350 if (SWIG_IsNewObj(res5)) delete temp;
11351 }
11352 }
11353 }
11354 {
11355 wxRect2D_Set(arg1,arg2,arg3,arg4,arg5);
11356 if (PyErr_Occurred()) SWIG_fail;
11357 }
11358 resultobj = SWIG_Py_Void();
11359 return resultobj;
11360 fail:
11361 return NULL;
11362 }
11363
11364
11365 SWIGINTERN PyObject *_wrap_Rect2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11366 PyObject *resultobj = 0;
11367 wxRect2D *arg1 = (wxRect2D *) 0 ;
11368 PyObject *result = 0 ;
11369 void *argp1 = 0 ;
11370 int res1 = 0 ;
11371 PyObject *swig_obj[1] ;
11372
11373 if (!args) SWIG_fail;
11374 swig_obj[0] = args;
11375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11376 if (!SWIG_IsOK(res1)) {
11377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11378 }
11379 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11380 {
11381 result = (PyObject *)wxRect2D_Get(arg1);
11382 if (PyErr_Occurred()) SWIG_fail;
11383 }
11384 resultobj = result;
11385 return resultobj;
11386 fail:
11387 return NULL;
11388 }
11389
11390
11391 SWIGINTERN PyObject *Rect2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11392 PyObject *obj;
11393 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11394 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect2D, SWIG_NewClientData(obj));
11395 return SWIG_Py_Void();
11396 }
11397
11398 SWIGINTERN PyObject *Rect2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11399 return SWIG_Python_InitShadowInstance(args);
11400 }
11401
11402 SWIGINTERN int DefaultPosition_set(PyObject *) {
11403 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
11404 return 1;
11405 }
11406
11407
11408 SWIGINTERN PyObject *DefaultPosition_get(void) {
11409 PyObject *pyobj = 0;
11410
11411 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
11412 return pyobj;
11413 }
11414
11415
11416 SWIGINTERN int DefaultSize_set(PyObject *) {
11417 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
11418 return 1;
11419 }
11420
11421
11422 SWIGINTERN PyObject *DefaultSize_get(void) {
11423 PyObject *pyobj = 0;
11424
11425 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
11426 return pyobj;
11427 }
11428
11429
11430 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11431 PyObject *resultobj = 0;
11432 PyObject *arg1 = (PyObject *) 0 ;
11433 wxPyInputStream *result = 0 ;
11434 PyObject * obj0 = 0 ;
11435 char * kwnames[] = {
11436 (char *) "p", NULL
11437 };
11438
11439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
11440 arg1 = obj0;
11441 {
11442 PyThreadState* __tstate = wxPyBeginAllowThreads();
11443 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
11444 wxPyEndAllowThreads(__tstate);
11445 if (PyErr_Occurred()) SWIG_fail;
11446 }
11447 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
11448 return resultobj;
11449 fail:
11450 return NULL;
11451 }
11452
11453
11454 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11455 PyObject *resultobj = 0;
11456 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11457 void *argp1 = 0 ;
11458 int res1 = 0 ;
11459 PyObject *swig_obj[1] ;
11460
11461 if (!args) SWIG_fail;
11462 swig_obj[0] = args;
11463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
11464 if (!SWIG_IsOK(res1)) {
11465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11466 }
11467 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11468 {
11469 PyThreadState* __tstate = wxPyBeginAllowThreads();
11470 delete arg1;
11471
11472 wxPyEndAllowThreads(__tstate);
11473 if (PyErr_Occurred()) SWIG_fail;
11474 }
11475 resultobj = SWIG_Py_Void();
11476 return resultobj;
11477 fail:
11478 return NULL;
11479 }
11480
11481
11482 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11483 PyObject *resultobj = 0;
11484 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11485 void *argp1 = 0 ;
11486 int res1 = 0 ;
11487 PyObject *swig_obj[1] ;
11488
11489 if (!args) SWIG_fail;
11490 swig_obj[0] = args;
11491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11492 if (!SWIG_IsOK(res1)) {
11493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11494 }
11495 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11496 {
11497 PyThreadState* __tstate = wxPyBeginAllowThreads();
11498 (arg1)->close();
11499 wxPyEndAllowThreads(__tstate);
11500 if (PyErr_Occurred()) SWIG_fail;
11501 }
11502 resultobj = SWIG_Py_Void();
11503 return resultobj;
11504 fail:
11505 return NULL;
11506 }
11507
11508
11509 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11510 PyObject *resultobj = 0;
11511 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11512 void *argp1 = 0 ;
11513 int res1 = 0 ;
11514 PyObject *swig_obj[1] ;
11515
11516 if (!args) SWIG_fail;
11517 swig_obj[0] = args;
11518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11519 if (!SWIG_IsOK(res1)) {
11520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11521 }
11522 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11523 {
11524 PyThreadState* __tstate = wxPyBeginAllowThreads();
11525 (arg1)->flush();
11526 wxPyEndAllowThreads(__tstate);
11527 if (PyErr_Occurred()) SWIG_fail;
11528 }
11529 resultobj = SWIG_Py_Void();
11530 return resultobj;
11531 fail:
11532 return NULL;
11533 }
11534
11535
11536 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11537 PyObject *resultobj = 0;
11538 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11539 bool result;
11540 void *argp1 = 0 ;
11541 int res1 = 0 ;
11542 PyObject *swig_obj[1] ;
11543
11544 if (!args) SWIG_fail;
11545 swig_obj[0] = args;
11546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11547 if (!SWIG_IsOK(res1)) {
11548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11549 }
11550 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11551 {
11552 PyThreadState* __tstate = wxPyBeginAllowThreads();
11553 result = (bool)(arg1)->eof();
11554 wxPyEndAllowThreads(__tstate);
11555 if (PyErr_Occurred()) SWIG_fail;
11556 }
11557 {
11558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11559 }
11560 return resultobj;
11561 fail:
11562 return NULL;
11563 }
11564
11565
11566 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11567 PyObject *resultobj = 0;
11568 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11569 int arg2 = (int) -1 ;
11570 PyObject *result = 0 ;
11571 void *argp1 = 0 ;
11572 int res1 = 0 ;
11573 int val2 ;
11574 int ecode2 = 0 ;
11575 PyObject * obj0 = 0 ;
11576 PyObject * obj1 = 0 ;
11577 char * kwnames[] = {
11578 (char *) "self",(char *) "size", NULL
11579 };
11580
11581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
11582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11583 if (!SWIG_IsOK(res1)) {
11584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11585 }
11586 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11587 if (obj1) {
11588 ecode2 = SWIG_AsVal_int(obj1, &val2);
11589 if (!SWIG_IsOK(ecode2)) {
11590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
11591 }
11592 arg2 = static_cast< int >(val2);
11593 }
11594 {
11595 PyThreadState* __tstate = wxPyBeginAllowThreads();
11596 result = (PyObject *)(arg1)->read(arg2);
11597 wxPyEndAllowThreads(__tstate);
11598 if (PyErr_Occurred()) SWIG_fail;
11599 }
11600 resultobj = result;
11601 return resultobj;
11602 fail:
11603 return NULL;
11604 }
11605
11606
11607 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11608 PyObject *resultobj = 0;
11609 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11610 int arg2 = (int) -1 ;
11611 PyObject *result = 0 ;
11612 void *argp1 = 0 ;
11613 int res1 = 0 ;
11614 int val2 ;
11615 int ecode2 = 0 ;
11616 PyObject * obj0 = 0 ;
11617 PyObject * obj1 = 0 ;
11618 char * kwnames[] = {
11619 (char *) "self",(char *) "size", NULL
11620 };
11621
11622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
11623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11624 if (!SWIG_IsOK(res1)) {
11625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11626 }
11627 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11628 if (obj1) {
11629 ecode2 = SWIG_AsVal_int(obj1, &val2);
11630 if (!SWIG_IsOK(ecode2)) {
11631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
11632 }
11633 arg2 = static_cast< int >(val2);
11634 }
11635 {
11636 PyThreadState* __tstate = wxPyBeginAllowThreads();
11637 result = (PyObject *)(arg1)->readline(arg2);
11638 wxPyEndAllowThreads(__tstate);
11639 if (PyErr_Occurred()) SWIG_fail;
11640 }
11641 resultobj = result;
11642 return resultobj;
11643 fail:
11644 return NULL;
11645 }
11646
11647
11648 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11649 PyObject *resultobj = 0;
11650 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11651 int arg2 = (int) -1 ;
11652 PyObject *result = 0 ;
11653 void *argp1 = 0 ;
11654 int res1 = 0 ;
11655 int val2 ;
11656 int ecode2 = 0 ;
11657 PyObject * obj0 = 0 ;
11658 PyObject * obj1 = 0 ;
11659 char * kwnames[] = {
11660 (char *) "self",(char *) "sizehint", NULL
11661 };
11662
11663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
11664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11665 if (!SWIG_IsOK(res1)) {
11666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11667 }
11668 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11669 if (obj1) {
11670 ecode2 = SWIG_AsVal_int(obj1, &val2);
11671 if (!SWIG_IsOK(ecode2)) {
11672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
11673 }
11674 arg2 = static_cast< int >(val2);
11675 }
11676 {
11677 PyThreadState* __tstate = wxPyBeginAllowThreads();
11678 result = (PyObject *)(arg1)->readlines(arg2);
11679 wxPyEndAllowThreads(__tstate);
11680 if (PyErr_Occurred()) SWIG_fail;
11681 }
11682 resultobj = result;
11683 return resultobj;
11684 fail:
11685 return NULL;
11686 }
11687
11688
11689 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11690 PyObject *resultobj = 0;
11691 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11692 int arg2 ;
11693 int arg3 = (int) 0 ;
11694 void *argp1 = 0 ;
11695 int res1 = 0 ;
11696 int val2 ;
11697 int ecode2 = 0 ;
11698 int val3 ;
11699 int ecode3 = 0 ;
11700 PyObject * obj0 = 0 ;
11701 PyObject * obj1 = 0 ;
11702 PyObject * obj2 = 0 ;
11703 char * kwnames[] = {
11704 (char *) "self",(char *) "offset",(char *) "whence", NULL
11705 };
11706
11707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11709 if (!SWIG_IsOK(res1)) {
11710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11711 }
11712 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11713 ecode2 = SWIG_AsVal_int(obj1, &val2);
11714 if (!SWIG_IsOK(ecode2)) {
11715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
11716 }
11717 arg2 = static_cast< int >(val2);
11718 if (obj2) {
11719 ecode3 = SWIG_AsVal_int(obj2, &val3);
11720 if (!SWIG_IsOK(ecode3)) {
11721 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
11722 }
11723 arg3 = static_cast< int >(val3);
11724 }
11725 {
11726 PyThreadState* __tstate = wxPyBeginAllowThreads();
11727 (arg1)->seek(arg2,arg3);
11728 wxPyEndAllowThreads(__tstate);
11729 if (PyErr_Occurred()) SWIG_fail;
11730 }
11731 resultobj = SWIG_Py_Void();
11732 return resultobj;
11733 fail:
11734 return NULL;
11735 }
11736
11737
11738 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11739 PyObject *resultobj = 0;
11740 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11741 int result;
11742 void *argp1 = 0 ;
11743 int res1 = 0 ;
11744 PyObject *swig_obj[1] ;
11745
11746 if (!args) SWIG_fail;
11747 swig_obj[0] = args;
11748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11749 if (!SWIG_IsOK(res1)) {
11750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11751 }
11752 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11753 {
11754 PyThreadState* __tstate = wxPyBeginAllowThreads();
11755 result = (int)(arg1)->tell();
11756 wxPyEndAllowThreads(__tstate);
11757 if (PyErr_Occurred()) SWIG_fail;
11758 }
11759 resultobj = SWIG_From_int(static_cast< int >(result));
11760 return resultobj;
11761 fail:
11762 return NULL;
11763 }
11764
11765
11766 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11767 PyObject *resultobj = 0;
11768 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11769 char result;
11770 void *argp1 = 0 ;
11771 int res1 = 0 ;
11772 PyObject *swig_obj[1] ;
11773
11774 if (!args) SWIG_fail;
11775 swig_obj[0] = args;
11776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11777 if (!SWIG_IsOK(res1)) {
11778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11779 }
11780 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11781 {
11782 PyThreadState* __tstate = wxPyBeginAllowThreads();
11783 result = (char)(arg1)->Peek();
11784 wxPyEndAllowThreads(__tstate);
11785 if (PyErr_Occurred()) SWIG_fail;
11786 }
11787 resultobj = SWIG_From_char(static_cast< char >(result));
11788 return resultobj;
11789 fail:
11790 return NULL;
11791 }
11792
11793
11794 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11795 PyObject *resultobj = 0;
11796 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11797 char result;
11798 void *argp1 = 0 ;
11799 int res1 = 0 ;
11800 PyObject *swig_obj[1] ;
11801
11802 if (!args) SWIG_fail;
11803 swig_obj[0] = args;
11804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11805 if (!SWIG_IsOK(res1)) {
11806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11807 }
11808 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11809 {
11810 PyThreadState* __tstate = wxPyBeginAllowThreads();
11811 result = (char)(arg1)->GetC();
11812 wxPyEndAllowThreads(__tstate);
11813 if (PyErr_Occurred()) SWIG_fail;
11814 }
11815 resultobj = SWIG_From_char(static_cast< char >(result));
11816 return resultobj;
11817 fail:
11818 return NULL;
11819 }
11820
11821
11822 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11823 PyObject *resultobj = 0;
11824 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11825 size_t result;
11826 void *argp1 = 0 ;
11827 int res1 = 0 ;
11828 PyObject *swig_obj[1] ;
11829
11830 if (!args) SWIG_fail;
11831 swig_obj[0] = args;
11832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11833 if (!SWIG_IsOK(res1)) {
11834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11835 }
11836 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11837 {
11838 PyThreadState* __tstate = wxPyBeginAllowThreads();
11839 result = (size_t)(arg1)->LastRead();
11840 wxPyEndAllowThreads(__tstate);
11841 if (PyErr_Occurred()) SWIG_fail;
11842 }
11843 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11844 return resultobj;
11845 fail:
11846 return NULL;
11847 }
11848
11849
11850 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11851 PyObject *resultobj = 0;
11852 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11853 bool result;
11854 void *argp1 = 0 ;
11855 int res1 = 0 ;
11856 PyObject *swig_obj[1] ;
11857
11858 if (!args) SWIG_fail;
11859 swig_obj[0] = args;
11860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11861 if (!SWIG_IsOK(res1)) {
11862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11863 }
11864 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11865 {
11866 PyThreadState* __tstate = wxPyBeginAllowThreads();
11867 result = (bool)(arg1)->CanRead();
11868 wxPyEndAllowThreads(__tstate);
11869 if (PyErr_Occurred()) SWIG_fail;
11870 }
11871 {
11872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11873 }
11874 return resultobj;
11875 fail:
11876 return NULL;
11877 }
11878
11879
11880 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11881 PyObject *resultobj = 0;
11882 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11883 bool result;
11884 void *argp1 = 0 ;
11885 int res1 = 0 ;
11886 PyObject *swig_obj[1] ;
11887
11888 if (!args) SWIG_fail;
11889 swig_obj[0] = args;
11890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11891 if (!SWIG_IsOK(res1)) {
11892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11893 }
11894 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11895 {
11896 PyThreadState* __tstate = wxPyBeginAllowThreads();
11897 result = (bool)(arg1)->Eof();
11898 wxPyEndAllowThreads(__tstate);
11899 if (PyErr_Occurred()) SWIG_fail;
11900 }
11901 {
11902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11903 }
11904 return resultobj;
11905 fail:
11906 return NULL;
11907 }
11908
11909
11910 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11911 PyObject *resultobj = 0;
11912 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11913 char arg2 ;
11914 bool result;
11915 void *argp1 = 0 ;
11916 int res1 = 0 ;
11917 char val2 ;
11918 int ecode2 = 0 ;
11919 PyObject * obj0 = 0 ;
11920 PyObject * obj1 = 0 ;
11921 char * kwnames[] = {
11922 (char *) "self",(char *) "c", NULL
11923 };
11924
11925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
11926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11927 if (!SWIG_IsOK(res1)) {
11928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11929 }
11930 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11931 ecode2 = SWIG_AsVal_char(obj1, &val2);
11932 if (!SWIG_IsOK(ecode2)) {
11933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
11934 }
11935 arg2 = static_cast< char >(val2);
11936 {
11937 PyThreadState* __tstate = wxPyBeginAllowThreads();
11938 result = (bool)(arg1)->Ungetch(arg2);
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_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11952 PyObject *resultobj = 0;
11953 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11954 long arg2 ;
11955 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
11956 long result;
11957 void *argp1 = 0 ;
11958 int res1 = 0 ;
11959 long val2 ;
11960 int ecode2 = 0 ;
11961 int val3 ;
11962 int ecode3 = 0 ;
11963 PyObject * obj0 = 0 ;
11964 PyObject * obj1 = 0 ;
11965 PyObject * obj2 = 0 ;
11966 char * kwnames[] = {
11967 (char *) "self",(char *) "pos",(char *) "mode", NULL
11968 };
11969
11970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11972 if (!SWIG_IsOK(res1)) {
11973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11974 }
11975 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11976 ecode2 = SWIG_AsVal_long(obj1, &val2);
11977 if (!SWIG_IsOK(ecode2)) {
11978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
11979 }
11980 arg2 = static_cast< long >(val2);
11981 if (obj2) {
11982 ecode3 = SWIG_AsVal_int(obj2, &val3);
11983 if (!SWIG_IsOK(ecode3)) {
11984 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
11985 }
11986 arg3 = static_cast< wxSeekMode >(val3);
11987 }
11988 {
11989 PyThreadState* __tstate = wxPyBeginAllowThreads();
11990 result = (long)(arg1)->SeekI(arg2,arg3);
11991 wxPyEndAllowThreads(__tstate);
11992 if (PyErr_Occurred()) SWIG_fail;
11993 }
11994 resultobj = SWIG_From_long(static_cast< long >(result));
11995 return resultobj;
11996 fail:
11997 return NULL;
11998 }
11999
12000
12001 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12002 PyObject *resultobj = 0;
12003 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12004 long result;
12005 void *argp1 = 0 ;
12006 int res1 = 0 ;
12007 PyObject *swig_obj[1] ;
12008
12009 if (!args) SWIG_fail;
12010 swig_obj[0] = args;
12011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12012 if (!SWIG_IsOK(res1)) {
12013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12014 }
12015 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12016 {
12017 PyThreadState* __tstate = wxPyBeginAllowThreads();
12018 result = (long)(arg1)->TellI();
12019 wxPyEndAllowThreads(__tstate);
12020 if (PyErr_Occurred()) SWIG_fail;
12021 }
12022 resultobj = SWIG_From_long(static_cast< long >(result));
12023 return resultobj;
12024 fail:
12025 return NULL;
12026 }
12027
12028
12029 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12030 PyObject *obj;
12031 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12032 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
12033 return SWIG_Py_Void();
12034 }
12035
12036 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12037 return SWIG_Python_InitShadowInstance(args);
12038 }
12039
12040 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12041 PyObject *resultobj = 0;
12042 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12043 PyObject *arg2 = (PyObject *) 0 ;
12044 void *argp1 = 0 ;
12045 int res1 = 0 ;
12046 PyObject * obj0 = 0 ;
12047 PyObject * obj1 = 0 ;
12048 char * kwnames[] = {
12049 (char *) "self",(char *) "obj", NULL
12050 };
12051
12052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
12053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12054 if (!SWIG_IsOK(res1)) {
12055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
12056 }
12057 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12058 arg2 = obj1;
12059 {
12060 PyThreadState* __tstate = wxPyBeginAllowThreads();
12061 wxOutputStream_write(arg1,arg2);
12062 wxPyEndAllowThreads(__tstate);
12063 if (PyErr_Occurred()) SWIG_fail;
12064 }
12065 resultobj = SWIG_Py_Void();
12066 return resultobj;
12067 fail:
12068 return NULL;
12069 }
12070
12071
12072 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12073 PyObject *resultobj = 0;
12074 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12075 size_t 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_wxOutputStream, 0 | 0 );
12083 if (!SWIG_IsOK(res1)) {
12084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
12085 }
12086 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12087 {
12088 PyThreadState* __tstate = wxPyBeginAllowThreads();
12089 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
12090 wxPyEndAllowThreads(__tstate);
12091 if (PyErr_Occurred()) SWIG_fail;
12092 }
12093 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12094 return resultobj;
12095 fail:
12096 return NULL;
12097 }
12098
12099
12100 SWIGINTERN PyObject *OutputStream_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_wxOutputStream, SWIG_NewClientData(obj));
12104 return SWIG_Py_Void();
12105 }
12106
12107 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12108 PyObject *resultobj = 0;
12109 wxInputStream *arg1 = (wxInputStream *) 0 ;
12110 wxString *arg2 = 0 ;
12111 wxString *arg3 = 0 ;
12112 wxString *arg4 = 0 ;
12113 wxDateTime arg5 ;
12114 wxFSFile *result = 0 ;
12115 wxPyInputStream *temp1 ;
12116 bool temp2 = false ;
12117 bool temp3 = false ;
12118 bool temp4 = false ;
12119 void *argp5 ;
12120 int res5 = 0 ;
12121 PyObject * obj0 = 0 ;
12122 PyObject * obj1 = 0 ;
12123 PyObject * obj2 = 0 ;
12124 PyObject * obj3 = 0 ;
12125 PyObject * obj4 = 0 ;
12126 char * kwnames[] = {
12127 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
12128 };
12129
12130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
12131 {
12132 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12133 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
12134 } else {
12135 PyErr_Clear(); // clear the failure of the wxPyConvert above
12136 arg1 = wxPyCBInputStream_create(obj0, true);
12137 if (arg1 == NULL) {
12138 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12139 SWIG_fail;
12140 }
12141 }
12142 }
12143 {
12144 arg2 = wxString_in_helper(obj1);
12145 if (arg2 == NULL) SWIG_fail;
12146 temp2 = true;
12147 }
12148 {
12149 arg3 = wxString_in_helper(obj2);
12150 if (arg3 == NULL) SWIG_fail;
12151 temp3 = true;
12152 }
12153 {
12154 arg4 = wxString_in_helper(obj3);
12155 if (arg4 == NULL) SWIG_fail;
12156 temp4 = true;
12157 }
12158 {
12159 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
12160 if (!SWIG_IsOK(res5)) {
12161 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12162 }
12163 if (!argp5) {
12164 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12165 } else {
12166 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
12167 arg5 = *temp;
12168 if (SWIG_IsNewObj(res5)) delete temp;
12169 }
12170 }
12171 {
12172 PyThreadState* __tstate = wxPyBeginAllowThreads();
12173 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
12174 wxPyEndAllowThreads(__tstate);
12175 if (PyErr_Occurred()) SWIG_fail;
12176 }
12177 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
12178 {
12179 if (temp2)
12180 delete arg2;
12181 }
12182 {
12183 if (temp3)
12184 delete arg3;
12185 }
12186 {
12187 if (temp4)
12188 delete arg4;
12189 }
12190 return resultobj;
12191 fail:
12192 {
12193 if (temp2)
12194 delete arg2;
12195 }
12196 {
12197 if (temp3)
12198 delete arg3;
12199 }
12200 {
12201 if (temp4)
12202 delete arg4;
12203 }
12204 return NULL;
12205 }
12206
12207
12208 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12209 PyObject *resultobj = 0;
12210 wxFSFile *arg1 = (wxFSFile *) 0 ;
12211 void *argp1 = 0 ;
12212 int res1 = 0 ;
12213 PyObject *swig_obj[1] ;
12214
12215 if (!args) SWIG_fail;
12216 swig_obj[0] = args;
12217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
12218 if (!SWIG_IsOK(res1)) {
12219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
12220 }
12221 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12222 {
12223 PyThreadState* __tstate = wxPyBeginAllowThreads();
12224 delete arg1;
12225
12226 wxPyEndAllowThreads(__tstate);
12227 if (PyErr_Occurred()) SWIG_fail;
12228 }
12229 resultobj = SWIG_Py_Void();
12230 return resultobj;
12231 fail:
12232 return NULL;
12233 }
12234
12235
12236 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12237 PyObject *resultobj = 0;
12238 wxFSFile *arg1 = (wxFSFile *) 0 ;
12239 wxInputStream *result = 0 ;
12240 void *argp1 = 0 ;
12241 int res1 = 0 ;
12242 PyObject *swig_obj[1] ;
12243
12244 if (!args) SWIG_fail;
12245 swig_obj[0] = args;
12246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12247 if (!SWIG_IsOK(res1)) {
12248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12249 }
12250 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12251 {
12252 PyThreadState* __tstate = wxPyBeginAllowThreads();
12253 result = (wxInputStream *)(arg1)->GetStream();
12254 wxPyEndAllowThreads(__tstate);
12255 if (PyErr_Occurred()) SWIG_fail;
12256 }
12257 {
12258 wxPyInputStream * _ptr = NULL;
12259
12260 if (result) {
12261 _ptr = new wxPyInputStream(result);
12262 }
12263 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
12264 }
12265 return resultobj;
12266 fail:
12267 return NULL;
12268 }
12269
12270
12271 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12272 PyObject *resultobj = 0;
12273 wxFSFile *arg1 = (wxFSFile *) 0 ;
12274 void *argp1 = 0 ;
12275 int res1 = 0 ;
12276 PyObject *swig_obj[1] ;
12277
12278 if (!args) SWIG_fail;
12279 swig_obj[0] = args;
12280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12281 if (!SWIG_IsOK(res1)) {
12282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12283 }
12284 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12285 {
12286 PyThreadState* __tstate = wxPyBeginAllowThreads();
12287 (arg1)->DetachStream();
12288 wxPyEndAllowThreads(__tstate);
12289 if (PyErr_Occurred()) SWIG_fail;
12290 }
12291 resultobj = SWIG_Py_Void();
12292 return resultobj;
12293 fail:
12294 return NULL;
12295 }
12296
12297
12298 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12299 PyObject *resultobj = 0;
12300 wxFSFile *arg1 = (wxFSFile *) 0 ;
12301 wxString *result = 0 ;
12302 void *argp1 = 0 ;
12303 int res1 = 0 ;
12304 PyObject *swig_obj[1] ;
12305
12306 if (!args) SWIG_fail;
12307 swig_obj[0] = args;
12308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12309 if (!SWIG_IsOK(res1)) {
12310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
12311 }
12312 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12313 {
12314 PyThreadState* __tstate = wxPyBeginAllowThreads();
12315 {
12316 wxString const &_result_ref = (arg1)->GetMimeType();
12317 result = (wxString *) &_result_ref;
12318 }
12319 wxPyEndAllowThreads(__tstate);
12320 if (PyErr_Occurred()) SWIG_fail;
12321 }
12322 {
12323 #if wxUSE_UNICODE
12324 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12325 #else
12326 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12327 #endif
12328 }
12329 return resultobj;
12330 fail:
12331 return NULL;
12332 }
12333
12334
12335 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12336 PyObject *resultobj = 0;
12337 wxFSFile *arg1 = (wxFSFile *) 0 ;
12338 wxString *result = 0 ;
12339 void *argp1 = 0 ;
12340 int res1 = 0 ;
12341 PyObject *swig_obj[1] ;
12342
12343 if (!args) SWIG_fail;
12344 swig_obj[0] = args;
12345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12346 if (!SWIG_IsOK(res1)) {
12347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
12348 }
12349 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12350 {
12351 PyThreadState* __tstate = wxPyBeginAllowThreads();
12352 {
12353 wxString const &_result_ref = (arg1)->GetLocation();
12354 result = (wxString *) &_result_ref;
12355 }
12356 wxPyEndAllowThreads(__tstate);
12357 if (PyErr_Occurred()) SWIG_fail;
12358 }
12359 {
12360 #if wxUSE_UNICODE
12361 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12362 #else
12363 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12364 #endif
12365 }
12366 return resultobj;
12367 fail:
12368 return NULL;
12369 }
12370
12371
12372 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12373 PyObject *resultobj = 0;
12374 wxFSFile *arg1 = (wxFSFile *) 0 ;
12375 wxString *result = 0 ;
12376 void *argp1 = 0 ;
12377 int res1 = 0 ;
12378 PyObject *swig_obj[1] ;
12379
12380 if (!args) SWIG_fail;
12381 swig_obj[0] = args;
12382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12383 if (!SWIG_IsOK(res1)) {
12384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
12385 }
12386 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12387 {
12388 PyThreadState* __tstate = wxPyBeginAllowThreads();
12389 {
12390 wxString const &_result_ref = (arg1)->GetAnchor();
12391 result = (wxString *) &_result_ref;
12392 }
12393 wxPyEndAllowThreads(__tstate);
12394 if (PyErr_Occurred()) SWIG_fail;
12395 }
12396 {
12397 #if wxUSE_UNICODE
12398 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12399 #else
12400 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12401 #endif
12402 }
12403 return resultobj;
12404 fail:
12405 return NULL;
12406 }
12407
12408
12409 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12410 PyObject *resultobj = 0;
12411 wxFSFile *arg1 = (wxFSFile *) 0 ;
12412 wxDateTime result;
12413 void *argp1 = 0 ;
12414 int res1 = 0 ;
12415 PyObject *swig_obj[1] ;
12416
12417 if (!args) SWIG_fail;
12418 swig_obj[0] = args;
12419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12420 if (!SWIG_IsOK(res1)) {
12421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
12422 }
12423 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12424 {
12425 PyThreadState* __tstate = wxPyBeginAllowThreads();
12426 result = (arg1)->GetModificationTime();
12427 wxPyEndAllowThreads(__tstate);
12428 if (PyErr_Occurred()) SWIG_fail;
12429 }
12430 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
12431 return resultobj;
12432 fail:
12433 return NULL;
12434 }
12435
12436
12437 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12438 PyObject *obj;
12439 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12440 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
12441 return SWIG_Py_Void();
12442 }
12443
12444 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12445 return SWIG_Python_InitShadowInstance(args);
12446 }
12447
12448 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12449 PyObject *resultobj = 0;
12450 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
12451 void *argp1 = 0 ;
12452 int res1 = 0 ;
12453 PyObject *swig_obj[1] ;
12454
12455 if (!args) SWIG_fail;
12456 swig_obj[0] = args;
12457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
12458 if (!SWIG_IsOK(res1)) {
12459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
12460 }
12461 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
12462 {
12463 PyThreadState* __tstate = wxPyBeginAllowThreads();
12464 delete arg1;
12465
12466 wxPyEndAllowThreads(__tstate);
12467 if (PyErr_Occurred()) SWIG_fail;
12468 }
12469 resultobj = SWIG_Py_Void();
12470 return resultobj;
12471 fail:
12472 return NULL;
12473 }
12474
12475
12476 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12477 PyObject *obj;
12478 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12479 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
12480 return SWIG_Py_Void();
12481 }
12482
12483 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12484 PyObject *resultobj = 0;
12485 wxPyFileSystemHandler *result = 0 ;
12486
12487 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
12488 {
12489 PyThreadState* __tstate = wxPyBeginAllowThreads();
12490 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
12491 wxPyEndAllowThreads(__tstate);
12492 if (PyErr_Occurred()) SWIG_fail;
12493 }
12494 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
12495 return resultobj;
12496 fail:
12497 return NULL;
12498 }
12499
12500
12501 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12502 PyObject *resultobj = 0;
12503 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12504 PyObject *arg2 = (PyObject *) 0 ;
12505 PyObject *arg3 = (PyObject *) 0 ;
12506 void *argp1 = 0 ;
12507 int res1 = 0 ;
12508 PyObject * obj0 = 0 ;
12509 PyObject * obj1 = 0 ;
12510 PyObject * obj2 = 0 ;
12511 char * kwnames[] = {
12512 (char *) "self",(char *) "self",(char *) "_class", NULL
12513 };
12514
12515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12517 if (!SWIG_IsOK(res1)) {
12518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12519 }
12520 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12521 arg2 = obj1;
12522 arg3 = obj2;
12523 {
12524 PyThreadState* __tstate = wxPyBeginAllowThreads();
12525 (arg1)->_setCallbackInfo(arg2,arg3);
12526 wxPyEndAllowThreads(__tstate);
12527 if (PyErr_Occurred()) SWIG_fail;
12528 }
12529 resultobj = SWIG_Py_Void();
12530 return resultobj;
12531 fail:
12532 return NULL;
12533 }
12534
12535
12536 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12537 PyObject *resultobj = 0;
12538 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12539 wxString *arg2 = 0 ;
12540 bool result;
12541 void *argp1 = 0 ;
12542 int res1 = 0 ;
12543 bool temp2 = false ;
12544 PyObject * obj0 = 0 ;
12545 PyObject * obj1 = 0 ;
12546 char * kwnames[] = {
12547 (char *) "self",(char *) "location", NULL
12548 };
12549
12550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
12551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12552 if (!SWIG_IsOK(res1)) {
12553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12554 }
12555 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12556 {
12557 arg2 = wxString_in_helper(obj1);
12558 if (arg2 == NULL) SWIG_fail;
12559 temp2 = true;
12560 }
12561 {
12562 PyThreadState* __tstate = wxPyBeginAllowThreads();
12563 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
12564 wxPyEndAllowThreads(__tstate);
12565 if (PyErr_Occurred()) SWIG_fail;
12566 }
12567 {
12568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12569 }
12570 {
12571 if (temp2)
12572 delete arg2;
12573 }
12574 return resultobj;
12575 fail:
12576 {
12577 if (temp2)
12578 delete arg2;
12579 }
12580 return NULL;
12581 }
12582
12583
12584 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12585 PyObject *resultobj = 0;
12586 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12587 wxFileSystem *arg2 = 0 ;
12588 wxString *arg3 = 0 ;
12589 wxFSFile *result = 0 ;
12590 void *argp1 = 0 ;
12591 int res1 = 0 ;
12592 void *argp2 = 0 ;
12593 int res2 = 0 ;
12594 bool temp3 = false ;
12595 PyObject * obj0 = 0 ;
12596 PyObject * obj1 = 0 ;
12597 PyObject * obj2 = 0 ;
12598 char * kwnames[] = {
12599 (char *) "self",(char *) "fs",(char *) "location", NULL
12600 };
12601
12602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12604 if (!SWIG_IsOK(res1)) {
12605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12606 }
12607 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12608 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
12609 if (!SWIG_IsOK(res2)) {
12610 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12611 }
12612 if (!argp2) {
12613 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12614 }
12615 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
12616 {
12617 arg3 = wxString_in_helper(obj2);
12618 if (arg3 == NULL) SWIG_fail;
12619 temp3 = true;
12620 }
12621 {
12622 PyThreadState* __tstate = wxPyBeginAllowThreads();
12623 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
12624 wxPyEndAllowThreads(__tstate);
12625 if (PyErr_Occurred()) SWIG_fail;
12626 }
12627 {
12628 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
12629 }
12630 {
12631 if (temp3)
12632 delete arg3;
12633 }
12634 return resultobj;
12635 fail:
12636 {
12637 if (temp3)
12638 delete arg3;
12639 }
12640 return NULL;
12641 }
12642
12643
12644 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12645 PyObject *resultobj = 0;
12646 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12647 wxString *arg2 = 0 ;
12648 int arg3 = (int) 0 ;
12649 wxString result;
12650 void *argp1 = 0 ;
12651 int res1 = 0 ;
12652 bool temp2 = false ;
12653 int val3 ;
12654 int ecode3 = 0 ;
12655 PyObject * obj0 = 0 ;
12656 PyObject * obj1 = 0 ;
12657 PyObject * obj2 = 0 ;
12658 char * kwnames[] = {
12659 (char *) "self",(char *) "spec",(char *) "flags", NULL
12660 };
12661
12662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12664 if (!SWIG_IsOK(res1)) {
12665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12666 }
12667 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12668 {
12669 arg2 = wxString_in_helper(obj1);
12670 if (arg2 == NULL) SWIG_fail;
12671 temp2 = true;
12672 }
12673 if (obj2) {
12674 ecode3 = SWIG_AsVal_int(obj2, &val3);
12675 if (!SWIG_IsOK(ecode3)) {
12676 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
12677 }
12678 arg3 = static_cast< int >(val3);
12679 }
12680 {
12681 PyThreadState* __tstate = wxPyBeginAllowThreads();
12682 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
12683 wxPyEndAllowThreads(__tstate);
12684 if (PyErr_Occurred()) SWIG_fail;
12685 }
12686 {
12687 #if wxUSE_UNICODE
12688 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12689 #else
12690 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12691 #endif
12692 }
12693 {
12694 if (temp2)
12695 delete arg2;
12696 }
12697 return resultobj;
12698 fail:
12699 {
12700 if (temp2)
12701 delete arg2;
12702 }
12703 return NULL;
12704 }
12705
12706
12707 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12708 PyObject *resultobj = 0;
12709 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12710 wxString result;
12711 void *argp1 = 0 ;
12712 int res1 = 0 ;
12713 PyObject *swig_obj[1] ;
12714
12715 if (!args) SWIG_fail;
12716 swig_obj[0] = args;
12717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12718 if (!SWIG_IsOK(res1)) {
12719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12720 }
12721 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12722 {
12723 PyThreadState* __tstate = wxPyBeginAllowThreads();
12724 result = (arg1)->FindNext();
12725 wxPyEndAllowThreads(__tstate);
12726 if (PyErr_Occurred()) SWIG_fail;
12727 }
12728 {
12729 #if wxUSE_UNICODE
12730 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12731 #else
12732 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12733 #endif
12734 }
12735 return resultobj;
12736 fail:
12737 return NULL;
12738 }
12739
12740
12741 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12742 PyObject *resultobj = 0;
12743 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12744 wxString *arg2 = 0 ;
12745 wxString result;
12746 void *argp1 = 0 ;
12747 int res1 = 0 ;
12748 bool temp2 = false ;
12749 PyObject * obj0 = 0 ;
12750 PyObject * obj1 = 0 ;
12751 char * kwnames[] = {
12752 (char *) "self",(char *) "location", NULL
12753 };
12754
12755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
12756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12757 if (!SWIG_IsOK(res1)) {
12758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12759 }
12760 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12761 {
12762 arg2 = wxString_in_helper(obj1);
12763 if (arg2 == NULL) SWIG_fail;
12764 temp2 = true;
12765 }
12766 {
12767 PyThreadState* __tstate = wxPyBeginAllowThreads();
12768 result = (arg1)->GetProtocol((wxString const &)*arg2);
12769 wxPyEndAllowThreads(__tstate);
12770 if (PyErr_Occurred()) SWIG_fail;
12771 }
12772 {
12773 #if wxUSE_UNICODE
12774 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12775 #else
12776 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12777 #endif
12778 }
12779 {
12780 if (temp2)
12781 delete arg2;
12782 }
12783 return resultobj;
12784 fail:
12785 {
12786 if (temp2)
12787 delete arg2;
12788 }
12789 return NULL;
12790 }
12791
12792
12793 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12794 PyObject *resultobj = 0;
12795 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12796 wxString *arg2 = 0 ;
12797 wxString result;
12798 void *argp1 = 0 ;
12799 int res1 = 0 ;
12800 bool temp2 = false ;
12801 PyObject * obj0 = 0 ;
12802 PyObject * obj1 = 0 ;
12803 char * kwnames[] = {
12804 (char *) "self",(char *) "location", NULL
12805 };
12806
12807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12809 if (!SWIG_IsOK(res1)) {
12810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12811 }
12812 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12813 {
12814 arg2 = wxString_in_helper(obj1);
12815 if (arg2 == NULL) SWIG_fail;
12816 temp2 = true;
12817 }
12818 {
12819 PyThreadState* __tstate = wxPyBeginAllowThreads();
12820 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
12821 wxPyEndAllowThreads(__tstate);
12822 if (PyErr_Occurred()) SWIG_fail;
12823 }
12824 {
12825 #if wxUSE_UNICODE
12826 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12827 #else
12828 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12829 #endif
12830 }
12831 {
12832 if (temp2)
12833 delete arg2;
12834 }
12835 return resultobj;
12836 fail:
12837 {
12838 if (temp2)
12839 delete arg2;
12840 }
12841 return NULL;
12842 }
12843
12844
12845 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12846 PyObject *resultobj = 0;
12847 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12848 wxString *arg2 = 0 ;
12849 wxString result;
12850 void *argp1 = 0 ;
12851 int res1 = 0 ;
12852 bool temp2 = false ;
12853 PyObject * obj0 = 0 ;
12854 PyObject * obj1 = 0 ;
12855 char * kwnames[] = {
12856 (char *) "self",(char *) "location", NULL
12857 };
12858
12859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
12860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12861 if (!SWIG_IsOK(res1)) {
12862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12863 }
12864 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12865 {
12866 arg2 = wxString_in_helper(obj1);
12867 if (arg2 == NULL) SWIG_fail;
12868 temp2 = true;
12869 }
12870 {
12871 PyThreadState* __tstate = wxPyBeginAllowThreads();
12872 result = (arg1)->GetAnchor((wxString const &)*arg2);
12873 wxPyEndAllowThreads(__tstate);
12874 if (PyErr_Occurred()) SWIG_fail;
12875 }
12876 {
12877 #if wxUSE_UNICODE
12878 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12879 #else
12880 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12881 #endif
12882 }
12883 {
12884 if (temp2)
12885 delete arg2;
12886 }
12887 return resultobj;
12888 fail:
12889 {
12890 if (temp2)
12891 delete arg2;
12892 }
12893 return NULL;
12894 }
12895
12896
12897 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12898 PyObject *resultobj = 0;
12899 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12900 wxString *arg2 = 0 ;
12901 wxString result;
12902 void *argp1 = 0 ;
12903 int res1 = 0 ;
12904 bool temp2 = false ;
12905 PyObject * obj0 = 0 ;
12906 PyObject * obj1 = 0 ;
12907 char * kwnames[] = {
12908 (char *) "self",(char *) "location", NULL
12909 };
12910
12911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12913 if (!SWIG_IsOK(res1)) {
12914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12915 }
12916 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12917 {
12918 arg2 = wxString_in_helper(obj1);
12919 if (arg2 == NULL) SWIG_fail;
12920 temp2 = true;
12921 }
12922 {
12923 PyThreadState* __tstate = wxPyBeginAllowThreads();
12924 result = (arg1)->GetRightLocation((wxString const &)*arg2);
12925 wxPyEndAllowThreads(__tstate);
12926 if (PyErr_Occurred()) SWIG_fail;
12927 }
12928 {
12929 #if wxUSE_UNICODE
12930 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12931 #else
12932 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12933 #endif
12934 }
12935 {
12936 if (temp2)
12937 delete arg2;
12938 }
12939 return resultobj;
12940 fail:
12941 {
12942 if (temp2)
12943 delete arg2;
12944 }
12945 return NULL;
12946 }
12947
12948
12949 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12950 PyObject *resultobj = 0;
12951 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12952 wxString *arg2 = 0 ;
12953 wxString result;
12954 void *argp1 = 0 ;
12955 int res1 = 0 ;
12956 bool temp2 = false ;
12957 PyObject * obj0 = 0 ;
12958 PyObject * obj1 = 0 ;
12959 char * kwnames[] = {
12960 (char *) "self",(char *) "location", NULL
12961 };
12962
12963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
12964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12965 if (!SWIG_IsOK(res1)) {
12966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12967 }
12968 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12969 {
12970 arg2 = wxString_in_helper(obj1);
12971 if (arg2 == NULL) SWIG_fail;
12972 temp2 = true;
12973 }
12974 {
12975 PyThreadState* __tstate = wxPyBeginAllowThreads();
12976 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
12977 wxPyEndAllowThreads(__tstate);
12978 if (PyErr_Occurred()) SWIG_fail;
12979 }
12980 {
12981 #if wxUSE_UNICODE
12982 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12983 #else
12984 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12985 #endif
12986 }
12987 {
12988 if (temp2)
12989 delete arg2;
12990 }
12991 return resultobj;
12992 fail:
12993 {
12994 if (temp2)
12995 delete arg2;
12996 }
12997 return NULL;
12998 }
12999
13000
13001 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13002 PyObject *obj;
13003 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13004 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
13005 return SWIG_Py_Void();
13006 }
13007
13008 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13009 return SWIG_Python_InitShadowInstance(args);
13010 }
13011
13012 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13013 PyObject *resultobj = 0;
13014 wxFileSystem *result = 0 ;
13015
13016 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
13017 {
13018 PyThreadState* __tstate = wxPyBeginAllowThreads();
13019 result = (wxFileSystem *)new wxFileSystem();
13020 wxPyEndAllowThreads(__tstate);
13021 if (PyErr_Occurred()) SWIG_fail;
13022 }
13023 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystem, SWIG_POINTER_NEW | 0 );
13024 return resultobj;
13025 fail:
13026 return NULL;
13027 }
13028
13029
13030 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13031 PyObject *resultobj = 0;
13032 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13033 void *argp1 = 0 ;
13034 int res1 = 0 ;
13035 PyObject *swig_obj[1] ;
13036
13037 if (!args) SWIG_fail;
13038 swig_obj[0] = args;
13039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
13040 if (!SWIG_IsOK(res1)) {
13041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13042 }
13043 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13044 {
13045 PyThreadState* __tstate = wxPyBeginAllowThreads();
13046 delete arg1;
13047
13048 wxPyEndAllowThreads(__tstate);
13049 if (PyErr_Occurred()) SWIG_fail;
13050 }
13051 resultobj = SWIG_Py_Void();
13052 return resultobj;
13053 fail:
13054 return NULL;
13055 }
13056
13057
13058 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13059 PyObject *resultobj = 0;
13060 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13061 wxString *arg2 = 0 ;
13062 bool arg3 = (bool) false ;
13063 void *argp1 = 0 ;
13064 int res1 = 0 ;
13065 bool temp2 = false ;
13066 bool val3 ;
13067 int ecode3 = 0 ;
13068 PyObject * obj0 = 0 ;
13069 PyObject * obj1 = 0 ;
13070 PyObject * obj2 = 0 ;
13071 char * kwnames[] = {
13072 (char *) "self",(char *) "location",(char *) "is_dir", NULL
13073 };
13074
13075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13077 if (!SWIG_IsOK(res1)) {
13078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13079 }
13080 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13081 {
13082 arg2 = wxString_in_helper(obj1);
13083 if (arg2 == NULL) SWIG_fail;
13084 temp2 = true;
13085 }
13086 if (obj2) {
13087 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13088 if (!SWIG_IsOK(ecode3)) {
13089 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
13090 }
13091 arg3 = static_cast< bool >(val3);
13092 }
13093 {
13094 PyThreadState* __tstate = wxPyBeginAllowThreads();
13095 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
13096 wxPyEndAllowThreads(__tstate);
13097 if (PyErr_Occurred()) SWIG_fail;
13098 }
13099 resultobj = SWIG_Py_Void();
13100 {
13101 if (temp2)
13102 delete arg2;
13103 }
13104 return resultobj;
13105 fail:
13106 {
13107 if (temp2)
13108 delete arg2;
13109 }
13110 return NULL;
13111 }
13112
13113
13114 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13115 PyObject *resultobj = 0;
13116 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13117 wxString result;
13118 void *argp1 = 0 ;
13119 int res1 = 0 ;
13120 PyObject *swig_obj[1] ;
13121
13122 if (!args) SWIG_fail;
13123 swig_obj[0] = args;
13124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13125 if (!SWIG_IsOK(res1)) {
13126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13127 }
13128 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13129 {
13130 PyThreadState* __tstate = wxPyBeginAllowThreads();
13131 result = (arg1)->GetPath();
13132 wxPyEndAllowThreads(__tstate);
13133 if (PyErr_Occurred()) SWIG_fail;
13134 }
13135 {
13136 #if wxUSE_UNICODE
13137 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13138 #else
13139 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13140 #endif
13141 }
13142 return resultobj;
13143 fail:
13144 return NULL;
13145 }
13146
13147
13148 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13149 PyObject *resultobj = 0;
13150 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13151 wxString *arg2 = 0 ;
13152 wxFSFile *result = 0 ;
13153 void *argp1 = 0 ;
13154 int res1 = 0 ;
13155 bool temp2 = false ;
13156 PyObject * obj0 = 0 ;
13157 PyObject * obj1 = 0 ;
13158 char * kwnames[] = {
13159 (char *) "self",(char *) "location", NULL
13160 };
13161
13162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
13163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13164 if (!SWIG_IsOK(res1)) {
13165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13166 }
13167 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13168 {
13169 arg2 = wxString_in_helper(obj1);
13170 if (arg2 == NULL) SWIG_fail;
13171 temp2 = true;
13172 }
13173 {
13174 PyThreadState* __tstate = wxPyBeginAllowThreads();
13175 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
13176 wxPyEndAllowThreads(__tstate);
13177 if (PyErr_Occurred()) SWIG_fail;
13178 }
13179 {
13180 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13181 }
13182 {
13183 if (temp2)
13184 delete arg2;
13185 }
13186 return resultobj;
13187 fail:
13188 {
13189 if (temp2)
13190 delete arg2;
13191 }
13192 return NULL;
13193 }
13194
13195
13196 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13197 PyObject *resultobj = 0;
13198 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13199 wxString *arg2 = 0 ;
13200 int arg3 = (int) 0 ;
13201 wxString result;
13202 void *argp1 = 0 ;
13203 int res1 = 0 ;
13204 bool temp2 = false ;
13205 int val3 ;
13206 int ecode3 = 0 ;
13207 PyObject * obj0 = 0 ;
13208 PyObject * obj1 = 0 ;
13209 PyObject * obj2 = 0 ;
13210 char * kwnames[] = {
13211 (char *) "self",(char *) "spec",(char *) "flags", NULL
13212 };
13213
13214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13216 if (!SWIG_IsOK(res1)) {
13217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13218 }
13219 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13220 {
13221 arg2 = wxString_in_helper(obj1);
13222 if (arg2 == NULL) SWIG_fail;
13223 temp2 = true;
13224 }
13225 if (obj2) {
13226 ecode3 = SWIG_AsVal_int(obj2, &val3);
13227 if (!SWIG_IsOK(ecode3)) {
13228 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
13229 }
13230 arg3 = static_cast< int >(val3);
13231 }
13232 {
13233 PyThreadState* __tstate = wxPyBeginAllowThreads();
13234 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13235 wxPyEndAllowThreads(__tstate);
13236 if (PyErr_Occurred()) SWIG_fail;
13237 }
13238 {
13239 #if wxUSE_UNICODE
13240 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13241 #else
13242 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13243 #endif
13244 }
13245 {
13246 if (temp2)
13247 delete arg2;
13248 }
13249 return resultobj;
13250 fail:
13251 {
13252 if (temp2)
13253 delete arg2;
13254 }
13255 return NULL;
13256 }
13257
13258
13259 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13260 PyObject *resultobj = 0;
13261 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13262 wxString result;
13263 void *argp1 = 0 ;
13264 int res1 = 0 ;
13265 PyObject *swig_obj[1] ;
13266
13267 if (!args) SWIG_fail;
13268 swig_obj[0] = args;
13269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13270 if (!SWIG_IsOK(res1)) {
13271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13272 }
13273 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13274 {
13275 PyThreadState* __tstate = wxPyBeginAllowThreads();
13276 result = (arg1)->FindNext();
13277 wxPyEndAllowThreads(__tstate);
13278 if (PyErr_Occurred()) SWIG_fail;
13279 }
13280 {
13281 #if wxUSE_UNICODE
13282 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13283 #else
13284 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13285 #endif
13286 }
13287 return resultobj;
13288 fail:
13289 return NULL;
13290 }
13291
13292
13293 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13294 PyObject *resultobj = 0;
13295 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13296 int res1 = 0 ;
13297 PyObject * obj0 = 0 ;
13298 char * kwnames[] = {
13299 (char *) "handler", NULL
13300 };
13301
13302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
13303 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
13304 if (!SWIG_IsOK(res1)) {
13305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13306 }
13307 {
13308 PyThreadState* __tstate = wxPyBeginAllowThreads();
13309 wxFileSystem::AddHandler(arg1);
13310 wxPyEndAllowThreads(__tstate);
13311 if (PyErr_Occurred()) SWIG_fail;
13312 }
13313 resultobj = SWIG_Py_Void();
13314 return resultobj;
13315 fail:
13316 return NULL;
13317 }
13318
13319
13320 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13321 PyObject *resultobj = 0;
13322 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13323 wxFileSystemHandler *result = 0 ;
13324 void *argp1 = 0 ;
13325 int res1 = 0 ;
13326 PyObject * obj0 = 0 ;
13327 char * kwnames[] = {
13328 (char *) "handler", NULL
13329 };
13330
13331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
13332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
13333 if (!SWIG_IsOK(res1)) {
13334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13335 }
13336 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
13337 {
13338 PyThreadState* __tstate = wxPyBeginAllowThreads();
13339 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
13340 wxPyEndAllowThreads(__tstate);
13341 if (PyErr_Occurred()) SWIG_fail;
13342 }
13343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
13344 return resultobj;
13345 fail:
13346 return NULL;
13347 }
13348
13349
13350 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13351 PyObject *resultobj = 0;
13352
13353 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
13354 {
13355 PyThreadState* __tstate = wxPyBeginAllowThreads();
13356 wxFileSystem::CleanUpHandlers();
13357 wxPyEndAllowThreads(__tstate);
13358 if (PyErr_Occurred()) SWIG_fail;
13359 }
13360 resultobj = SWIG_Py_Void();
13361 return resultobj;
13362 fail:
13363 return NULL;
13364 }
13365
13366
13367 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13368 PyObject *resultobj = 0;
13369 wxString *arg1 = 0 ;
13370 wxString result;
13371 bool temp1 = false ;
13372 PyObject * obj0 = 0 ;
13373 char * kwnames[] = {
13374 (char *) "filename", NULL
13375 };
13376
13377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
13378 {
13379 arg1 = wxString_in_helper(obj0);
13380 if (arg1 == NULL) SWIG_fail;
13381 temp1 = true;
13382 }
13383 {
13384 PyThreadState* __tstate = wxPyBeginAllowThreads();
13385 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
13386 wxPyEndAllowThreads(__tstate);
13387 if (PyErr_Occurred()) SWIG_fail;
13388 }
13389 {
13390 #if wxUSE_UNICODE
13391 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13392 #else
13393 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13394 #endif
13395 }
13396 {
13397 if (temp1)
13398 delete arg1;
13399 }
13400 return resultobj;
13401 fail:
13402 {
13403 if (temp1)
13404 delete arg1;
13405 }
13406 return NULL;
13407 }
13408
13409
13410 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13411 PyObject *resultobj = 0;
13412 wxString *arg1 = 0 ;
13413 wxString result;
13414 bool temp1 = false ;
13415 PyObject * obj0 = 0 ;
13416 char * kwnames[] = {
13417 (char *) "url", NULL
13418 };
13419
13420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
13421 {
13422 arg1 = wxString_in_helper(obj0);
13423 if (arg1 == NULL) SWIG_fail;
13424 temp1 = true;
13425 }
13426 {
13427 PyThreadState* __tstate = wxPyBeginAllowThreads();
13428 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
13429 wxPyEndAllowThreads(__tstate);
13430 if (PyErr_Occurred()) SWIG_fail;
13431 }
13432 {
13433 #if wxUSE_UNICODE
13434 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13435 #else
13436 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13437 #endif
13438 }
13439 {
13440 if (temp1)
13441 delete arg1;
13442 }
13443 return resultobj;
13444 fail:
13445 {
13446 if (temp1)
13447 delete arg1;
13448 }
13449 return NULL;
13450 }
13451
13452
13453 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13454 PyObject *obj;
13455 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13456 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
13457 return SWIG_Py_Void();
13458 }
13459
13460 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13461 return SWIG_Python_InitShadowInstance(args);
13462 }
13463
13464 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13465 PyObject *resultobj = 0;
13466 wxInternetFSHandler *result = 0 ;
13467
13468 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
13469 {
13470 PyThreadState* __tstate = wxPyBeginAllowThreads();
13471 result = (wxInternetFSHandler *)new wxInternetFSHandler();
13472 wxPyEndAllowThreads(__tstate);
13473 if (PyErr_Occurred()) SWIG_fail;
13474 }
13475 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
13476 return resultobj;
13477 fail:
13478 return NULL;
13479 }
13480
13481
13482 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13483 PyObject *resultobj = 0;
13484 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13485 wxString *arg2 = 0 ;
13486 bool result;
13487 void *argp1 = 0 ;
13488 int res1 = 0 ;
13489 bool temp2 = false ;
13490 PyObject * obj0 = 0 ;
13491 PyObject * obj1 = 0 ;
13492 char * kwnames[] = {
13493 (char *) "self",(char *) "location", NULL
13494 };
13495
13496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13498 if (!SWIG_IsOK(res1)) {
13499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13500 }
13501 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13502 {
13503 arg2 = wxString_in_helper(obj1);
13504 if (arg2 == NULL) SWIG_fail;
13505 temp2 = true;
13506 }
13507 {
13508 PyThreadState* __tstate = wxPyBeginAllowThreads();
13509 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13510 wxPyEndAllowThreads(__tstate);
13511 if (PyErr_Occurred()) SWIG_fail;
13512 }
13513 {
13514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13515 }
13516 {
13517 if (temp2)
13518 delete arg2;
13519 }
13520 return resultobj;
13521 fail:
13522 {
13523 if (temp2)
13524 delete arg2;
13525 }
13526 return NULL;
13527 }
13528
13529
13530 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13531 PyObject *resultobj = 0;
13532 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13533 wxFileSystem *arg2 = 0 ;
13534 wxString *arg3 = 0 ;
13535 wxFSFile *result = 0 ;
13536 void *argp1 = 0 ;
13537 int res1 = 0 ;
13538 void *argp2 = 0 ;
13539 int res2 = 0 ;
13540 bool temp3 = false ;
13541 PyObject * obj0 = 0 ;
13542 PyObject * obj1 = 0 ;
13543 PyObject * obj2 = 0 ;
13544 char * kwnames[] = {
13545 (char *) "self",(char *) "fs",(char *) "location", NULL
13546 };
13547
13548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13550 if (!SWIG_IsOK(res1)) {
13551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13552 }
13553 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13554 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13555 if (!SWIG_IsOK(res2)) {
13556 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13557 }
13558 if (!argp2) {
13559 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13560 }
13561 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13562 {
13563 arg3 = wxString_in_helper(obj2);
13564 if (arg3 == NULL) SWIG_fail;
13565 temp3 = true;
13566 }
13567 {
13568 PyThreadState* __tstate = wxPyBeginAllowThreads();
13569 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13570 wxPyEndAllowThreads(__tstate);
13571 if (PyErr_Occurred()) SWIG_fail;
13572 }
13573 {
13574 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13575 }
13576 {
13577 if (temp3)
13578 delete arg3;
13579 }
13580 return resultobj;
13581 fail:
13582 {
13583 if (temp3)
13584 delete arg3;
13585 }
13586 return NULL;
13587 }
13588
13589
13590 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13591 PyObject *obj;
13592 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13593 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
13594 return SWIG_Py_Void();
13595 }
13596
13597 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13598 return SWIG_Python_InitShadowInstance(args);
13599 }
13600
13601 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13602 PyObject *resultobj = 0;
13603 wxZipFSHandler *result = 0 ;
13604
13605 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
13606 {
13607 PyThreadState* __tstate = wxPyBeginAllowThreads();
13608 result = (wxZipFSHandler *)new wxZipFSHandler();
13609 wxPyEndAllowThreads(__tstate);
13610 if (PyErr_Occurred()) SWIG_fail;
13611 }
13612 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
13613 return resultobj;
13614 fail:
13615 return NULL;
13616 }
13617
13618
13619 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13620 PyObject *resultobj = 0;
13621 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13622 wxString *arg2 = 0 ;
13623 bool result;
13624 void *argp1 = 0 ;
13625 int res1 = 0 ;
13626 bool temp2 = false ;
13627 PyObject * obj0 = 0 ;
13628 PyObject * obj1 = 0 ;
13629 char * kwnames[] = {
13630 (char *) "self",(char *) "location", NULL
13631 };
13632
13633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13635 if (!SWIG_IsOK(res1)) {
13636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13637 }
13638 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13639 {
13640 arg2 = wxString_in_helper(obj1);
13641 if (arg2 == NULL) SWIG_fail;
13642 temp2 = true;
13643 }
13644 {
13645 PyThreadState* __tstate = wxPyBeginAllowThreads();
13646 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13647 wxPyEndAllowThreads(__tstate);
13648 if (PyErr_Occurred()) SWIG_fail;
13649 }
13650 {
13651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13652 }
13653 {
13654 if (temp2)
13655 delete arg2;
13656 }
13657 return resultobj;
13658 fail:
13659 {
13660 if (temp2)
13661 delete arg2;
13662 }
13663 return NULL;
13664 }
13665
13666
13667 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13668 PyObject *resultobj = 0;
13669 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13670 wxFileSystem *arg2 = 0 ;
13671 wxString *arg3 = 0 ;
13672 wxFSFile *result = 0 ;
13673 void *argp1 = 0 ;
13674 int res1 = 0 ;
13675 void *argp2 = 0 ;
13676 int res2 = 0 ;
13677 bool temp3 = false ;
13678 PyObject * obj0 = 0 ;
13679 PyObject * obj1 = 0 ;
13680 PyObject * obj2 = 0 ;
13681 char * kwnames[] = {
13682 (char *) "self",(char *) "fs",(char *) "location", NULL
13683 };
13684
13685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13687 if (!SWIG_IsOK(res1)) {
13688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13689 }
13690 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13691 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13692 if (!SWIG_IsOK(res2)) {
13693 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13694 }
13695 if (!argp2) {
13696 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13697 }
13698 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13699 {
13700 arg3 = wxString_in_helper(obj2);
13701 if (arg3 == NULL) SWIG_fail;
13702 temp3 = true;
13703 }
13704 {
13705 PyThreadState* __tstate = wxPyBeginAllowThreads();
13706 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13707 wxPyEndAllowThreads(__tstate);
13708 if (PyErr_Occurred()) SWIG_fail;
13709 }
13710 {
13711 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13712 }
13713 {
13714 if (temp3)
13715 delete arg3;
13716 }
13717 return resultobj;
13718 fail:
13719 {
13720 if (temp3)
13721 delete arg3;
13722 }
13723 return NULL;
13724 }
13725
13726
13727 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13728 PyObject *resultobj = 0;
13729 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13730 wxString *arg2 = 0 ;
13731 int arg3 = (int) 0 ;
13732 wxString result;
13733 void *argp1 = 0 ;
13734 int res1 = 0 ;
13735 bool temp2 = false ;
13736 int val3 ;
13737 int ecode3 = 0 ;
13738 PyObject * obj0 = 0 ;
13739 PyObject * obj1 = 0 ;
13740 PyObject * obj2 = 0 ;
13741 char * kwnames[] = {
13742 (char *) "self",(char *) "spec",(char *) "flags", NULL
13743 };
13744
13745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13747 if (!SWIG_IsOK(res1)) {
13748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13749 }
13750 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13751 {
13752 arg2 = wxString_in_helper(obj1);
13753 if (arg2 == NULL) SWIG_fail;
13754 temp2 = true;
13755 }
13756 if (obj2) {
13757 ecode3 = SWIG_AsVal_int(obj2, &val3);
13758 if (!SWIG_IsOK(ecode3)) {
13759 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
13760 }
13761 arg3 = static_cast< int >(val3);
13762 }
13763 {
13764 PyThreadState* __tstate = wxPyBeginAllowThreads();
13765 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13766 wxPyEndAllowThreads(__tstate);
13767 if (PyErr_Occurred()) SWIG_fail;
13768 }
13769 {
13770 #if wxUSE_UNICODE
13771 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13772 #else
13773 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13774 #endif
13775 }
13776 {
13777 if (temp2)
13778 delete arg2;
13779 }
13780 return resultobj;
13781 fail:
13782 {
13783 if (temp2)
13784 delete arg2;
13785 }
13786 return NULL;
13787 }
13788
13789
13790 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13791 PyObject *resultobj = 0;
13792 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13793 wxString result;
13794 void *argp1 = 0 ;
13795 int res1 = 0 ;
13796 PyObject *swig_obj[1] ;
13797
13798 if (!args) SWIG_fail;
13799 swig_obj[0] = args;
13800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13801 if (!SWIG_IsOK(res1)) {
13802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13803 }
13804 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13805 {
13806 PyThreadState* __tstate = wxPyBeginAllowThreads();
13807 result = (arg1)->FindNext();
13808 wxPyEndAllowThreads(__tstate);
13809 if (PyErr_Occurred()) SWIG_fail;
13810 }
13811 {
13812 #if wxUSE_UNICODE
13813 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13814 #else
13815 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13816 #endif
13817 }
13818 return resultobj;
13819 fail:
13820 return NULL;
13821 }
13822
13823
13824 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13825 PyObject *obj;
13826 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13827 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
13828 return SWIG_Py_Void();
13829 }
13830
13831 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13832 return SWIG_Python_InitShadowInstance(args);
13833 }
13834
13835 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13836 PyObject *resultobj = 0;
13837 wxString *arg1 = 0 ;
13838 wxImage *arg2 = 0 ;
13839 long arg3 ;
13840 bool temp1 = false ;
13841 void *argp2 = 0 ;
13842 int res2 = 0 ;
13843 long val3 ;
13844 int ecode3 = 0 ;
13845 PyObject * obj0 = 0 ;
13846 PyObject * obj1 = 0 ;
13847 PyObject * obj2 = 0 ;
13848 char * kwnames[] = {
13849 (char *) "filename",(char *) "image",(char *) "type", NULL
13850 };
13851
13852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13853 {
13854 arg1 = wxString_in_helper(obj0);
13855 if (arg1 == NULL) SWIG_fail;
13856 temp1 = true;
13857 }
13858 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
13859 if (!SWIG_IsOK(res2)) {
13860 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13861 }
13862 if (!argp2) {
13863 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13864 }
13865 arg2 = reinterpret_cast< wxImage * >(argp2);
13866 ecode3 = SWIG_AsVal_long(obj2, &val3);
13867 if (!SWIG_IsOK(ecode3)) {
13868 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
13869 }
13870 arg3 = static_cast< long >(val3);
13871 {
13872 PyThreadState* __tstate = wxPyBeginAllowThreads();
13873 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
13874 wxPyEndAllowThreads(__tstate);
13875 if (PyErr_Occurred()) SWIG_fail;
13876 }
13877 resultobj = SWIG_Py_Void();
13878 {
13879 if (temp1)
13880 delete arg1;
13881 }
13882 return resultobj;
13883 fail:
13884 {
13885 if (temp1)
13886 delete arg1;
13887 }
13888 return NULL;
13889 }
13890
13891
13892 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13893 PyObject *resultobj = 0;
13894 wxString *arg1 = 0 ;
13895 wxBitmap *arg2 = 0 ;
13896 long arg3 ;
13897 bool temp1 = false ;
13898 void *argp2 = 0 ;
13899 int res2 = 0 ;
13900 long val3 ;
13901 int ecode3 = 0 ;
13902 PyObject * obj0 = 0 ;
13903 PyObject * obj1 = 0 ;
13904 PyObject * obj2 = 0 ;
13905 char * kwnames[] = {
13906 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
13907 };
13908
13909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13910 {
13911 arg1 = wxString_in_helper(obj0);
13912 if (arg1 == NULL) SWIG_fail;
13913 temp1 = true;
13914 }
13915 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
13916 if (!SWIG_IsOK(res2)) {
13917 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13918 }
13919 if (!argp2) {
13920 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13921 }
13922 arg2 = reinterpret_cast< wxBitmap * >(argp2);
13923 ecode3 = SWIG_AsVal_long(obj2, &val3);
13924 if (!SWIG_IsOK(ecode3)) {
13925 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
13926 }
13927 arg3 = static_cast< long >(val3);
13928 {
13929 PyThreadState* __tstate = wxPyBeginAllowThreads();
13930 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
13931 wxPyEndAllowThreads(__tstate);
13932 if (PyErr_Occurred()) SWIG_fail;
13933 }
13934 resultobj = SWIG_Py_Void();
13935 {
13936 if (temp1)
13937 delete arg1;
13938 }
13939 return resultobj;
13940 fail:
13941 {
13942 if (temp1)
13943 delete arg1;
13944 }
13945 return NULL;
13946 }
13947
13948
13949 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13950 PyObject *resultobj = 0;
13951 wxString *arg1 = 0 ;
13952 PyObject *arg2 = (PyObject *) 0 ;
13953 bool temp1 = false ;
13954 PyObject * obj0 = 0 ;
13955 PyObject * obj1 = 0 ;
13956 char * kwnames[] = {
13957 (char *) "filename",(char *) "data", NULL
13958 };
13959
13960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
13961 {
13962 arg1 = wxString_in_helper(obj0);
13963 if (arg1 == NULL) SWIG_fail;
13964 temp1 = true;
13965 }
13966 arg2 = obj1;
13967 {
13968 PyThreadState* __tstate = wxPyBeginAllowThreads();
13969 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
13970 wxPyEndAllowThreads(__tstate);
13971 if (PyErr_Occurred()) SWIG_fail;
13972 }
13973 resultobj = SWIG_Py_Void();
13974 {
13975 if (temp1)
13976 delete arg1;
13977 }
13978 return resultobj;
13979 fail:
13980 {
13981 if (temp1)
13982 delete arg1;
13983 }
13984 return NULL;
13985 }
13986
13987
13988 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13989 PyObject *resultobj = 0;
13990 wxMemoryFSHandler *result = 0 ;
13991
13992 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
13993 {
13994 PyThreadState* __tstate = wxPyBeginAllowThreads();
13995 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
13996 wxPyEndAllowThreads(__tstate);
13997 if (PyErr_Occurred()) SWIG_fail;
13998 }
13999 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
14000 return resultobj;
14001 fail:
14002 return NULL;
14003 }
14004
14005
14006 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14007 PyObject *resultobj = 0;
14008 wxString *arg1 = 0 ;
14009 bool temp1 = false ;
14010 PyObject * obj0 = 0 ;
14011 char * kwnames[] = {
14012 (char *) "filename", NULL
14013 };
14014
14015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
14016 {
14017 arg1 = wxString_in_helper(obj0);
14018 if (arg1 == NULL) SWIG_fail;
14019 temp1 = true;
14020 }
14021 {
14022 PyThreadState* __tstate = wxPyBeginAllowThreads();
14023 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
14024 wxPyEndAllowThreads(__tstate);
14025 if (PyErr_Occurred()) SWIG_fail;
14026 }
14027 resultobj = SWIG_Py_Void();
14028 {
14029 if (temp1)
14030 delete arg1;
14031 }
14032 return resultobj;
14033 fail:
14034 {
14035 if (temp1)
14036 delete arg1;
14037 }
14038 return NULL;
14039 }
14040
14041
14042 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14043 PyObject *resultobj = 0;
14044 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14045 wxString *arg2 = 0 ;
14046 bool result;
14047 void *argp1 = 0 ;
14048 int res1 = 0 ;
14049 bool temp2 = false ;
14050 PyObject * obj0 = 0 ;
14051 PyObject * obj1 = 0 ;
14052 char * kwnames[] = {
14053 (char *) "self",(char *) "location", NULL
14054 };
14055
14056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
14057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14058 if (!SWIG_IsOK(res1)) {
14059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14060 }
14061 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14062 {
14063 arg2 = wxString_in_helper(obj1);
14064 if (arg2 == NULL) SWIG_fail;
14065 temp2 = true;
14066 }
14067 {
14068 PyThreadState* __tstate = wxPyBeginAllowThreads();
14069 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
14070 wxPyEndAllowThreads(__tstate);
14071 if (PyErr_Occurred()) SWIG_fail;
14072 }
14073 {
14074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14075 }
14076 {
14077 if (temp2)
14078 delete arg2;
14079 }
14080 return resultobj;
14081 fail:
14082 {
14083 if (temp2)
14084 delete arg2;
14085 }
14086 return NULL;
14087 }
14088
14089
14090 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14091 PyObject *resultobj = 0;
14092 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14093 wxFileSystem *arg2 = 0 ;
14094 wxString *arg3 = 0 ;
14095 wxFSFile *result = 0 ;
14096 void *argp1 = 0 ;
14097 int res1 = 0 ;
14098 void *argp2 = 0 ;
14099 int res2 = 0 ;
14100 bool temp3 = false ;
14101 PyObject * obj0 = 0 ;
14102 PyObject * obj1 = 0 ;
14103 PyObject * obj2 = 0 ;
14104 char * kwnames[] = {
14105 (char *) "self",(char *) "fs",(char *) "location", NULL
14106 };
14107
14108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14110 if (!SWIG_IsOK(res1)) {
14111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14112 }
14113 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14114 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
14115 if (!SWIG_IsOK(res2)) {
14116 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14117 }
14118 if (!argp2) {
14119 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14120 }
14121 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
14122 {
14123 arg3 = wxString_in_helper(obj2);
14124 if (arg3 == NULL) SWIG_fail;
14125 temp3 = true;
14126 }
14127 {
14128 PyThreadState* __tstate = wxPyBeginAllowThreads();
14129 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
14130 wxPyEndAllowThreads(__tstate);
14131 if (PyErr_Occurred()) SWIG_fail;
14132 }
14133 {
14134 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
14135 }
14136 {
14137 if (temp3)
14138 delete arg3;
14139 }
14140 return resultobj;
14141 fail:
14142 {
14143 if (temp3)
14144 delete arg3;
14145 }
14146 return NULL;
14147 }
14148
14149
14150 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14151 PyObject *resultobj = 0;
14152 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14153 wxString *arg2 = 0 ;
14154 int arg3 = (int) 0 ;
14155 wxString result;
14156 void *argp1 = 0 ;
14157 int res1 = 0 ;
14158 bool temp2 = false ;
14159 int val3 ;
14160 int ecode3 = 0 ;
14161 PyObject * obj0 = 0 ;
14162 PyObject * obj1 = 0 ;
14163 PyObject * obj2 = 0 ;
14164 char * kwnames[] = {
14165 (char *) "self",(char *) "spec",(char *) "flags", NULL
14166 };
14167
14168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14170 if (!SWIG_IsOK(res1)) {
14171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14172 }
14173 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14174 {
14175 arg2 = wxString_in_helper(obj1);
14176 if (arg2 == NULL) SWIG_fail;
14177 temp2 = true;
14178 }
14179 if (obj2) {
14180 ecode3 = SWIG_AsVal_int(obj2, &val3);
14181 if (!SWIG_IsOK(ecode3)) {
14182 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
14183 }
14184 arg3 = static_cast< int >(val3);
14185 }
14186 {
14187 PyThreadState* __tstate = wxPyBeginAllowThreads();
14188 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
14189 wxPyEndAllowThreads(__tstate);
14190 if (PyErr_Occurred()) SWIG_fail;
14191 }
14192 {
14193 #if wxUSE_UNICODE
14194 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14195 #else
14196 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14197 #endif
14198 }
14199 {
14200 if (temp2)
14201 delete arg2;
14202 }
14203 return resultobj;
14204 fail:
14205 {
14206 if (temp2)
14207 delete arg2;
14208 }
14209 return NULL;
14210 }
14211
14212
14213 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14214 PyObject *resultobj = 0;
14215 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14216 wxString result;
14217 void *argp1 = 0 ;
14218 int res1 = 0 ;
14219 PyObject *swig_obj[1] ;
14220
14221 if (!args) SWIG_fail;
14222 swig_obj[0] = args;
14223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14224 if (!SWIG_IsOK(res1)) {
14225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14226 }
14227 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14228 {
14229 PyThreadState* __tstate = wxPyBeginAllowThreads();
14230 result = (arg1)->FindNext();
14231 wxPyEndAllowThreads(__tstate);
14232 if (PyErr_Occurred()) SWIG_fail;
14233 }
14234 {
14235 #if wxUSE_UNICODE
14236 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14237 #else
14238 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14239 #endif
14240 }
14241 return resultobj;
14242 fail:
14243 return NULL;
14244 }
14245
14246
14247 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14248 PyObject *obj;
14249 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14250 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
14251 return SWIG_Py_Void();
14252 }
14253
14254 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14255 return SWIG_Python_InitShadowInstance(args);
14256 }
14257
14258 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14259 PyObject *resultobj = 0;
14260 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14261 wxString result;
14262 void *argp1 = 0 ;
14263 int res1 = 0 ;
14264 PyObject *swig_obj[1] ;
14265
14266 if (!args) SWIG_fail;
14267 swig_obj[0] = args;
14268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14269 if (!SWIG_IsOK(res1)) {
14270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14271 }
14272 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14273 {
14274 PyThreadState* __tstate = wxPyBeginAllowThreads();
14275 result = (arg1)->GetName();
14276 wxPyEndAllowThreads(__tstate);
14277 if (PyErr_Occurred()) SWIG_fail;
14278 }
14279 {
14280 #if wxUSE_UNICODE
14281 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14282 #else
14283 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14284 #endif
14285 }
14286 return resultobj;
14287 fail:
14288 return NULL;
14289 }
14290
14291
14292 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14293 PyObject *resultobj = 0;
14294 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14295 wxString result;
14296 void *argp1 = 0 ;
14297 int res1 = 0 ;
14298 PyObject *swig_obj[1] ;
14299
14300 if (!args) SWIG_fail;
14301 swig_obj[0] = args;
14302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14303 if (!SWIG_IsOK(res1)) {
14304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14305 }
14306 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14307 {
14308 PyThreadState* __tstate = wxPyBeginAllowThreads();
14309 result = (arg1)->GetExtension();
14310 wxPyEndAllowThreads(__tstate);
14311 if (PyErr_Occurred()) SWIG_fail;
14312 }
14313 {
14314 #if wxUSE_UNICODE
14315 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14316 #else
14317 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14318 #endif
14319 }
14320 return resultobj;
14321 fail:
14322 return NULL;
14323 }
14324
14325
14326 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14327 PyObject *resultobj = 0;
14328 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14329 long result;
14330 void *argp1 = 0 ;
14331 int res1 = 0 ;
14332 PyObject *swig_obj[1] ;
14333
14334 if (!args) SWIG_fail;
14335 swig_obj[0] = args;
14336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14337 if (!SWIG_IsOK(res1)) {
14338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14339 }
14340 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14341 {
14342 PyThreadState* __tstate = wxPyBeginAllowThreads();
14343 result = (long)(arg1)->GetType();
14344 wxPyEndAllowThreads(__tstate);
14345 if (PyErr_Occurred()) SWIG_fail;
14346 }
14347 resultobj = SWIG_From_long(static_cast< long >(result));
14348 return resultobj;
14349 fail:
14350 return NULL;
14351 }
14352
14353
14354 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14355 PyObject *resultobj = 0;
14356 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14357 wxString result;
14358 void *argp1 = 0 ;
14359 int res1 = 0 ;
14360 PyObject *swig_obj[1] ;
14361
14362 if (!args) SWIG_fail;
14363 swig_obj[0] = args;
14364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14365 if (!SWIG_IsOK(res1)) {
14366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14367 }
14368 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14369 {
14370 PyThreadState* __tstate = wxPyBeginAllowThreads();
14371 result = (arg1)->GetMimeType();
14372 wxPyEndAllowThreads(__tstate);
14373 if (PyErr_Occurred()) SWIG_fail;
14374 }
14375 {
14376 #if wxUSE_UNICODE
14377 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14378 #else
14379 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14380 #endif
14381 }
14382 return resultobj;
14383 fail:
14384 return NULL;
14385 }
14386
14387
14388 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14389 PyObject *resultobj = 0;
14390 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14391 wxString *arg2 = 0 ;
14392 bool result;
14393 void *argp1 = 0 ;
14394 int res1 = 0 ;
14395 bool temp2 = false ;
14396 PyObject * obj0 = 0 ;
14397 PyObject * obj1 = 0 ;
14398 char * kwnames[] = {
14399 (char *) "self",(char *) "name", NULL
14400 };
14401
14402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
14403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14404 if (!SWIG_IsOK(res1)) {
14405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14406 }
14407 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14408 {
14409 arg2 = wxString_in_helper(obj1);
14410 if (arg2 == NULL) SWIG_fail;
14411 temp2 = true;
14412 }
14413 {
14414 PyThreadState* __tstate = wxPyBeginAllowThreads();
14415 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
14416 wxPyEndAllowThreads(__tstate);
14417 if (PyErr_Occurred()) SWIG_fail;
14418 }
14419 {
14420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14421 }
14422 {
14423 if (temp2)
14424 delete arg2;
14425 }
14426 return resultobj;
14427 fail:
14428 {
14429 if (temp2)
14430 delete arg2;
14431 }
14432 return NULL;
14433 }
14434
14435
14436 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14437 PyObject *resultobj = 0;
14438 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14439 wxInputStream *arg2 = 0 ;
14440 bool result;
14441 void *argp1 = 0 ;
14442 int res1 = 0 ;
14443 wxPyInputStream *temp2 ;
14444 bool created2 ;
14445 PyObject * obj0 = 0 ;
14446 PyObject * obj1 = 0 ;
14447 char * kwnames[] = {
14448 (char *) "self",(char *) "stream", NULL
14449 };
14450
14451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
14452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14453 if (!SWIG_IsOK(res1)) {
14454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14455 }
14456 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14457 {
14458 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14459 arg2 = temp2->m_wxis;
14460 created2 = false;
14461 } else {
14462 PyErr_Clear(); // clear the failure of the wxPyConvert above
14463 arg2 = wxPyCBInputStream_create(obj1, false);
14464 if (arg2 == NULL) {
14465 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14466 SWIG_fail;
14467 }
14468 created2 = true;
14469 }
14470 }
14471 {
14472 PyThreadState* __tstate = wxPyBeginAllowThreads();
14473 result = (bool)(arg1)->CanRead(*arg2);
14474 wxPyEndAllowThreads(__tstate);
14475 if (PyErr_Occurred()) SWIG_fail;
14476 }
14477 {
14478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14479 }
14480 {
14481 if (created2) delete arg2;
14482 }
14483 return resultobj;
14484 fail:
14485 {
14486 if (created2) delete arg2;
14487 }
14488 return NULL;
14489 }
14490
14491
14492 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14493 PyObject *resultobj = 0;
14494 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14495 wxString *arg2 = 0 ;
14496 void *argp1 = 0 ;
14497 int res1 = 0 ;
14498 bool temp2 = false ;
14499 PyObject * obj0 = 0 ;
14500 PyObject * obj1 = 0 ;
14501 char * kwnames[] = {
14502 (char *) "self",(char *) "name", NULL
14503 };
14504
14505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
14506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14507 if (!SWIG_IsOK(res1)) {
14508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14509 }
14510 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14511 {
14512 arg2 = wxString_in_helper(obj1);
14513 if (arg2 == NULL) SWIG_fail;
14514 temp2 = true;
14515 }
14516 {
14517 PyThreadState* __tstate = wxPyBeginAllowThreads();
14518 (arg1)->SetName((wxString const &)*arg2);
14519 wxPyEndAllowThreads(__tstate);
14520 if (PyErr_Occurred()) SWIG_fail;
14521 }
14522 resultobj = SWIG_Py_Void();
14523 {
14524 if (temp2)
14525 delete arg2;
14526 }
14527 return resultobj;
14528 fail:
14529 {
14530 if (temp2)
14531 delete arg2;
14532 }
14533 return NULL;
14534 }
14535
14536
14537 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14538 PyObject *resultobj = 0;
14539 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14540 wxString *arg2 = 0 ;
14541 void *argp1 = 0 ;
14542 int res1 = 0 ;
14543 bool temp2 = false ;
14544 PyObject * obj0 = 0 ;
14545 PyObject * obj1 = 0 ;
14546 char * kwnames[] = {
14547 (char *) "self",(char *) "extension", NULL
14548 };
14549
14550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
14551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14552 if (!SWIG_IsOK(res1)) {
14553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14554 }
14555 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14556 {
14557 arg2 = wxString_in_helper(obj1);
14558 if (arg2 == NULL) SWIG_fail;
14559 temp2 = true;
14560 }
14561 {
14562 PyThreadState* __tstate = wxPyBeginAllowThreads();
14563 (arg1)->SetExtension((wxString const &)*arg2);
14564 wxPyEndAllowThreads(__tstate);
14565 if (PyErr_Occurred()) SWIG_fail;
14566 }
14567 resultobj = SWIG_Py_Void();
14568 {
14569 if (temp2)
14570 delete arg2;
14571 }
14572 return resultobj;
14573 fail:
14574 {
14575 if (temp2)
14576 delete arg2;
14577 }
14578 return NULL;
14579 }
14580
14581
14582 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14583 PyObject *resultobj = 0;
14584 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14585 long arg2 ;
14586 void *argp1 = 0 ;
14587 int res1 = 0 ;
14588 long val2 ;
14589 int ecode2 = 0 ;
14590 PyObject * obj0 = 0 ;
14591 PyObject * obj1 = 0 ;
14592 char * kwnames[] = {
14593 (char *) "self",(char *) "type", NULL
14594 };
14595
14596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
14597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14598 if (!SWIG_IsOK(res1)) {
14599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14600 }
14601 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14602 ecode2 = SWIG_AsVal_long(obj1, &val2);
14603 if (!SWIG_IsOK(ecode2)) {
14604 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
14605 }
14606 arg2 = static_cast< long >(val2);
14607 {
14608 PyThreadState* __tstate = wxPyBeginAllowThreads();
14609 (arg1)->SetType(arg2);
14610 wxPyEndAllowThreads(__tstate);
14611 if (PyErr_Occurred()) SWIG_fail;
14612 }
14613 resultobj = SWIG_Py_Void();
14614 return resultobj;
14615 fail:
14616 return NULL;
14617 }
14618
14619
14620 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14621 PyObject *resultobj = 0;
14622 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14623 wxString *arg2 = 0 ;
14624 void *argp1 = 0 ;
14625 int res1 = 0 ;
14626 bool temp2 = false ;
14627 PyObject * obj0 = 0 ;
14628 PyObject * obj1 = 0 ;
14629 char * kwnames[] = {
14630 (char *) "self",(char *) "mimetype", NULL
14631 };
14632
14633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
14634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14635 if (!SWIG_IsOK(res1)) {
14636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14637 }
14638 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14639 {
14640 arg2 = wxString_in_helper(obj1);
14641 if (arg2 == NULL) SWIG_fail;
14642 temp2 = true;
14643 }
14644 {
14645 PyThreadState* __tstate = wxPyBeginAllowThreads();
14646 (arg1)->SetMimeType((wxString const &)*arg2);
14647 wxPyEndAllowThreads(__tstate);
14648 if (PyErr_Occurred()) SWIG_fail;
14649 }
14650 resultobj = SWIG_Py_Void();
14651 {
14652 if (temp2)
14653 delete arg2;
14654 }
14655 return resultobj;
14656 fail:
14657 {
14658 if (temp2)
14659 delete arg2;
14660 }
14661 return NULL;
14662 }
14663
14664
14665 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14666 PyObject *obj;
14667 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14668 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
14669 return SWIG_Py_Void();
14670 }
14671
14672 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14673 PyObject *resultobj = 0;
14674 wxPyImageHandler *result = 0 ;
14675
14676 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
14677 {
14678 PyThreadState* __tstate = wxPyBeginAllowThreads();
14679 result = (wxPyImageHandler *)new wxPyImageHandler();
14680 wxPyEndAllowThreads(__tstate);
14681 if (PyErr_Occurred()) SWIG_fail;
14682 }
14683 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
14684 return resultobj;
14685 fail:
14686 return NULL;
14687 }
14688
14689
14690 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14691 PyObject *resultobj = 0;
14692 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
14693 PyObject *arg2 = (PyObject *) 0 ;
14694 void *argp1 = 0 ;
14695 int res1 = 0 ;
14696 PyObject * obj0 = 0 ;
14697 PyObject * obj1 = 0 ;
14698 char * kwnames[] = {
14699 (char *) "self",(char *) "self", NULL
14700 };
14701
14702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
14703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
14704 if (!SWIG_IsOK(res1)) {
14705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
14706 }
14707 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
14708 arg2 = obj1;
14709 {
14710 PyThreadState* __tstate = wxPyBeginAllowThreads();
14711 (arg1)->_SetSelf(arg2);
14712 wxPyEndAllowThreads(__tstate);
14713 if (PyErr_Occurred()) SWIG_fail;
14714 }
14715 resultobj = SWIG_Py_Void();
14716 return resultobj;
14717 fail:
14718 return NULL;
14719 }
14720
14721
14722 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14723 PyObject *obj;
14724 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14725 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
14726 return SWIG_Py_Void();
14727 }
14728
14729 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14730 return SWIG_Python_InitShadowInstance(args);
14731 }
14732
14733 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14734 PyObject *resultobj = 0;
14735 wxImageHistogram *result = 0 ;
14736
14737 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
14738 {
14739 PyThreadState* __tstate = wxPyBeginAllowThreads();
14740 result = (wxImageHistogram *)new wxImageHistogram();
14741 wxPyEndAllowThreads(__tstate);
14742 if (PyErr_Occurred()) SWIG_fail;
14743 }
14744 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
14745 return resultobj;
14746 fail:
14747 return NULL;
14748 }
14749
14750
14751 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14752 PyObject *resultobj = 0;
14753 byte arg1 ;
14754 byte arg2 ;
14755 byte arg3 ;
14756 unsigned long result;
14757 unsigned char val1 ;
14758 int ecode1 = 0 ;
14759 unsigned char val2 ;
14760 int ecode2 = 0 ;
14761 unsigned char val3 ;
14762 int ecode3 = 0 ;
14763 PyObject * obj0 = 0 ;
14764 PyObject * obj1 = 0 ;
14765 PyObject * obj2 = 0 ;
14766 char * kwnames[] = {
14767 (char *) "r",(char *) "g",(char *) "b", NULL
14768 };
14769
14770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14771 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
14772 if (!SWIG_IsOK(ecode1)) {
14773 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
14774 }
14775 arg1 = static_cast< byte >(val1);
14776 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14777 if (!SWIG_IsOK(ecode2)) {
14778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
14779 }
14780 arg2 = static_cast< byte >(val2);
14781 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14782 if (!SWIG_IsOK(ecode3)) {
14783 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
14784 }
14785 arg3 = static_cast< byte >(val3);
14786 {
14787 PyThreadState* __tstate = wxPyBeginAllowThreads();
14788 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
14789 wxPyEndAllowThreads(__tstate);
14790 if (PyErr_Occurred()) SWIG_fail;
14791 }
14792 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14793 return resultobj;
14794 fail:
14795 return NULL;
14796 }
14797
14798
14799 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14800 PyObject *resultobj = 0;
14801 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14802 byte *arg2 = (byte *) 0 ;
14803 byte *arg3 = (byte *) 0 ;
14804 byte *arg4 = (byte *) 0 ;
14805 byte arg5 = (byte) 1 ;
14806 byte arg6 = (byte) 0 ;
14807 byte arg7 = (byte) 0 ;
14808 bool result;
14809 void *argp1 = 0 ;
14810 int res1 = 0 ;
14811 byte temp2 ;
14812 int res2 = SWIG_TMPOBJ ;
14813 byte temp3 ;
14814 int res3 = SWIG_TMPOBJ ;
14815 byte temp4 ;
14816 int res4 = SWIG_TMPOBJ ;
14817 unsigned char val5 ;
14818 int ecode5 = 0 ;
14819 unsigned char val6 ;
14820 int ecode6 = 0 ;
14821 unsigned char val7 ;
14822 int ecode7 = 0 ;
14823 PyObject * obj0 = 0 ;
14824 PyObject * obj1 = 0 ;
14825 PyObject * obj2 = 0 ;
14826 PyObject * obj3 = 0 ;
14827 char * kwnames[] = {
14828 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14829 };
14830
14831 arg2 = &temp2;
14832 arg3 = &temp3;
14833 arg4 = &temp4;
14834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14836 if (!SWIG_IsOK(res1)) {
14837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
14838 }
14839 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14840 if (obj1) {
14841 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14842 if (!SWIG_IsOK(ecode5)) {
14843 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14844 }
14845 arg5 = static_cast< byte >(val5);
14846 }
14847 if (obj2) {
14848 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14849 if (!SWIG_IsOK(ecode6)) {
14850 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14851 }
14852 arg6 = static_cast< byte >(val6);
14853 }
14854 if (obj3) {
14855 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14856 if (!SWIG_IsOK(ecode7)) {
14857 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14858 }
14859 arg7 = static_cast< byte >(val7);
14860 }
14861 {
14862 PyThreadState* __tstate = wxPyBeginAllowThreads();
14863 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14864 wxPyEndAllowThreads(__tstate);
14865 if (PyErr_Occurred()) SWIG_fail;
14866 }
14867 {
14868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14869 }
14870 if (SWIG_IsTmpObj(res2)) {
14871 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14872 } else {
14873 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14874 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14875 }
14876 if (SWIG_IsTmpObj(res3)) {
14877 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14878 } else {
14879 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14880 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14881 }
14882 if (SWIG_IsTmpObj(res4)) {
14883 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14884 } else {
14885 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14886 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14887 }
14888 return resultobj;
14889 fail:
14890 return NULL;
14891 }
14892
14893
14894 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14895 PyObject *resultobj = 0;
14896 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14897 unsigned long arg2 ;
14898 unsigned long result;
14899 void *argp1 = 0 ;
14900 int res1 = 0 ;
14901 unsigned long val2 ;
14902 int ecode2 = 0 ;
14903 PyObject * obj0 = 0 ;
14904 PyObject * obj1 = 0 ;
14905 char * kwnames[] = {
14906 (char *) "self",(char *) "key", NULL
14907 };
14908
14909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
14910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14911 if (!SWIG_IsOK(res1)) {
14912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14913 }
14914 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14915 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
14916 if (!SWIG_IsOK(ecode2)) {
14917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
14918 }
14919 arg2 = static_cast< unsigned long >(val2);
14920 {
14921 PyThreadState* __tstate = wxPyBeginAllowThreads();
14922 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
14923 wxPyEndAllowThreads(__tstate);
14924 if (PyErr_Occurred()) SWIG_fail;
14925 }
14926 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14927 return resultobj;
14928 fail:
14929 return NULL;
14930 }
14931
14932
14933 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14934 PyObject *resultobj = 0;
14935 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14936 byte arg2 ;
14937 byte arg3 ;
14938 byte arg4 ;
14939 unsigned long result;
14940 void *argp1 = 0 ;
14941 int res1 = 0 ;
14942 unsigned char val2 ;
14943 int ecode2 = 0 ;
14944 unsigned char val3 ;
14945 int ecode3 = 0 ;
14946 unsigned char val4 ;
14947 int ecode4 = 0 ;
14948 PyObject * obj0 = 0 ;
14949 PyObject * obj1 = 0 ;
14950 PyObject * obj2 = 0 ;
14951 PyObject * obj3 = 0 ;
14952 char * kwnames[] = {
14953 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14954 };
14955
14956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14958 if (!SWIG_IsOK(res1)) {
14959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14960 }
14961 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14962 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14963 if (!SWIG_IsOK(ecode2)) {
14964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
14965 }
14966 arg2 = static_cast< byte >(val2);
14967 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14968 if (!SWIG_IsOK(ecode3)) {
14969 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
14970 }
14971 arg3 = static_cast< byte >(val3);
14972 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14973 if (!SWIG_IsOK(ecode4)) {
14974 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
14975 }
14976 arg4 = static_cast< byte >(val4);
14977 {
14978 PyThreadState* __tstate = wxPyBeginAllowThreads();
14979 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
14980 wxPyEndAllowThreads(__tstate);
14981 if (PyErr_Occurred()) SWIG_fail;
14982 }
14983 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14984 return resultobj;
14985 fail:
14986 return NULL;
14987 }
14988
14989
14990 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14991 PyObject *resultobj = 0;
14992 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14993 wxColour *arg2 = 0 ;
14994 unsigned long result;
14995 void *argp1 = 0 ;
14996 int res1 = 0 ;
14997 wxColour temp2 ;
14998 PyObject * obj0 = 0 ;
14999 PyObject * obj1 = 0 ;
15000 char * kwnames[] = {
15001 (char *) "self",(char *) "colour", NULL
15002 };
15003
15004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
15005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15006 if (!SWIG_IsOK(res1)) {
15007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
15008 }
15009 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15010 {
15011 arg2 = &temp2;
15012 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
15013 }
15014 {
15015 PyThreadState* __tstate = wxPyBeginAllowThreads();
15016 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
15017 wxPyEndAllowThreads(__tstate);
15018 if (PyErr_Occurred()) SWIG_fail;
15019 }
15020 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15021 return resultobj;
15022 fail:
15023 return NULL;
15024 }
15025
15026
15027 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15028 PyObject *obj;
15029 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15030 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
15031 return SWIG_Py_Void();
15032 }
15033
15034 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15035 return SWIG_Python_InitShadowInstance(args);
15036 }
15037
15038 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15039 PyObject *resultobj = 0;
15040 byte arg1 = (byte) 0 ;
15041 byte arg2 = (byte) 0 ;
15042 byte arg3 = (byte) 0 ;
15043 wxImage_RGBValue *result = 0 ;
15044 unsigned char val1 ;
15045 int ecode1 = 0 ;
15046 unsigned char val2 ;
15047 int ecode2 = 0 ;
15048 unsigned char val3 ;
15049 int ecode3 = 0 ;
15050 PyObject * obj0 = 0 ;
15051 PyObject * obj1 = 0 ;
15052 PyObject * obj2 = 0 ;
15053 char * kwnames[] = {
15054 (char *) "r",(char *) "g",(char *) "b", NULL
15055 };
15056
15057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15058 if (obj0) {
15059 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
15060 if (!SWIG_IsOK(ecode1)) {
15061 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
15062 }
15063 arg1 = static_cast< byte >(val1);
15064 }
15065 if (obj1) {
15066 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15067 if (!SWIG_IsOK(ecode2)) {
15068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
15069 }
15070 arg2 = static_cast< byte >(val2);
15071 }
15072 if (obj2) {
15073 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15074 if (!SWIG_IsOK(ecode3)) {
15075 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
15076 }
15077 arg3 = static_cast< byte >(val3);
15078 }
15079 {
15080 PyThreadState* __tstate = wxPyBeginAllowThreads();
15081 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
15082 wxPyEndAllowThreads(__tstate);
15083 if (PyErr_Occurred()) SWIG_fail;
15084 }
15085 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
15086 return resultobj;
15087 fail:
15088 return NULL;
15089 }
15090
15091
15092 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15093 PyObject *resultobj = 0;
15094 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15095 byte arg2 ;
15096 void *argp1 = 0 ;
15097 int res1 = 0 ;
15098 unsigned char val2 ;
15099 int ecode2 = 0 ;
15100 PyObject *swig_obj[2] ;
15101
15102 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
15103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15104 if (!SWIG_IsOK(res1)) {
15105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15106 }
15107 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15108 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15109 if (!SWIG_IsOK(ecode2)) {
15110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
15111 }
15112 arg2 = static_cast< byte >(val2);
15113 if (arg1) (arg1)->red = arg2;
15114
15115 resultobj = SWIG_Py_Void();
15116 return resultobj;
15117 fail:
15118 return NULL;
15119 }
15120
15121
15122 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15123 PyObject *resultobj = 0;
15124 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15125 byte result;
15126 void *argp1 = 0 ;
15127 int res1 = 0 ;
15128 PyObject *swig_obj[1] ;
15129
15130 if (!args) SWIG_fail;
15131 swig_obj[0] = args;
15132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15133 if (!SWIG_IsOK(res1)) {
15134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15135 }
15136 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15137 result = (byte) ((arg1)->red);
15138 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15139 return resultobj;
15140 fail:
15141 return NULL;
15142 }
15143
15144
15145 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15146 PyObject *resultobj = 0;
15147 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15148 byte arg2 ;
15149 void *argp1 = 0 ;
15150 int res1 = 0 ;
15151 unsigned char val2 ;
15152 int ecode2 = 0 ;
15153 PyObject *swig_obj[2] ;
15154
15155 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
15156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15157 if (!SWIG_IsOK(res1)) {
15158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15159 }
15160 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15161 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15162 if (!SWIG_IsOK(ecode2)) {
15163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
15164 }
15165 arg2 = static_cast< byte >(val2);
15166 if (arg1) (arg1)->green = arg2;
15167
15168 resultobj = SWIG_Py_Void();
15169 return resultobj;
15170 fail:
15171 return NULL;
15172 }
15173
15174
15175 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15176 PyObject *resultobj = 0;
15177 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15178 byte result;
15179 void *argp1 = 0 ;
15180 int res1 = 0 ;
15181 PyObject *swig_obj[1] ;
15182
15183 if (!args) SWIG_fail;
15184 swig_obj[0] = args;
15185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15186 if (!SWIG_IsOK(res1)) {
15187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15188 }
15189 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15190 result = (byte) ((arg1)->green);
15191 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15192 return resultobj;
15193 fail:
15194 return NULL;
15195 }
15196
15197
15198 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15199 PyObject *resultobj = 0;
15200 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15201 byte arg2 ;
15202 void *argp1 = 0 ;
15203 int res1 = 0 ;
15204 unsigned char val2 ;
15205 int ecode2 = 0 ;
15206 PyObject *swig_obj[2] ;
15207
15208 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
15209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15210 if (!SWIG_IsOK(res1)) {
15211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15212 }
15213 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15214 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15215 if (!SWIG_IsOK(ecode2)) {
15216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
15217 }
15218 arg2 = static_cast< byte >(val2);
15219 if (arg1) (arg1)->blue = arg2;
15220
15221 resultobj = SWIG_Py_Void();
15222 return resultobj;
15223 fail:
15224 return NULL;
15225 }
15226
15227
15228 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15229 PyObject *resultobj = 0;
15230 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15231 byte result;
15232 void *argp1 = 0 ;
15233 int res1 = 0 ;
15234 PyObject *swig_obj[1] ;
15235
15236 if (!args) SWIG_fail;
15237 swig_obj[0] = args;
15238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15239 if (!SWIG_IsOK(res1)) {
15240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15241 }
15242 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15243 result = (byte) ((arg1)->blue);
15244 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15245 return resultobj;
15246 fail:
15247 return NULL;
15248 }
15249
15250
15251 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15252 PyObject *obj;
15253 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15254 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
15255 return SWIG_Py_Void();
15256 }
15257
15258 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15259 return SWIG_Python_InitShadowInstance(args);
15260 }
15261
15262 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15263 PyObject *resultobj = 0;
15264 double arg1 = (double) 0.0 ;
15265 double arg2 = (double) 0.0 ;
15266 double arg3 = (double) 0.0 ;
15267 wxImage_HSVValue *result = 0 ;
15268 double val1 ;
15269 int ecode1 = 0 ;
15270 double val2 ;
15271 int ecode2 = 0 ;
15272 double val3 ;
15273 int ecode3 = 0 ;
15274 PyObject * obj0 = 0 ;
15275 PyObject * obj1 = 0 ;
15276 PyObject * obj2 = 0 ;
15277 char * kwnames[] = {
15278 (char *) "h",(char *) "s",(char *) "v", NULL
15279 };
15280
15281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15282 if (obj0) {
15283 ecode1 = SWIG_AsVal_double(obj0, &val1);
15284 if (!SWIG_IsOK(ecode1)) {
15285 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
15286 }
15287 arg1 = static_cast< double >(val1);
15288 }
15289 if (obj1) {
15290 ecode2 = SWIG_AsVal_double(obj1, &val2);
15291 if (!SWIG_IsOK(ecode2)) {
15292 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
15293 }
15294 arg2 = static_cast< double >(val2);
15295 }
15296 if (obj2) {
15297 ecode3 = SWIG_AsVal_double(obj2, &val3);
15298 if (!SWIG_IsOK(ecode3)) {
15299 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
15300 }
15301 arg3 = static_cast< double >(val3);
15302 }
15303 {
15304 PyThreadState* __tstate = wxPyBeginAllowThreads();
15305 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
15306 wxPyEndAllowThreads(__tstate);
15307 if (PyErr_Occurred()) SWIG_fail;
15308 }
15309 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
15310 return resultobj;
15311 fail:
15312 return NULL;
15313 }
15314
15315
15316 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15317 PyObject *resultobj = 0;
15318 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15319 double arg2 ;
15320 void *argp1 = 0 ;
15321 int res1 = 0 ;
15322 double val2 ;
15323 int ecode2 = 0 ;
15324 PyObject *swig_obj[2] ;
15325
15326 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
15327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15328 if (!SWIG_IsOK(res1)) {
15329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15330 }
15331 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15332 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15333 if (!SWIG_IsOK(ecode2)) {
15334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
15335 }
15336 arg2 = static_cast< double >(val2);
15337 if (arg1) (arg1)->hue = arg2;
15338
15339 resultobj = SWIG_Py_Void();
15340 return resultobj;
15341 fail:
15342 return NULL;
15343 }
15344
15345
15346 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15347 PyObject *resultobj = 0;
15348 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15349 double result;
15350 void *argp1 = 0 ;
15351 int res1 = 0 ;
15352 PyObject *swig_obj[1] ;
15353
15354 if (!args) SWIG_fail;
15355 swig_obj[0] = args;
15356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15357 if (!SWIG_IsOK(res1)) {
15358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15359 }
15360 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15361 result = (double) ((arg1)->hue);
15362 resultobj = SWIG_From_double(static_cast< double >(result));
15363 return resultobj;
15364 fail:
15365 return NULL;
15366 }
15367
15368
15369 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15370 PyObject *resultobj = 0;
15371 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15372 double arg2 ;
15373 void *argp1 = 0 ;
15374 int res1 = 0 ;
15375 double val2 ;
15376 int ecode2 = 0 ;
15377 PyObject *swig_obj[2] ;
15378
15379 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
15380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15381 if (!SWIG_IsOK(res1)) {
15382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15383 }
15384 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15385 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15386 if (!SWIG_IsOK(ecode2)) {
15387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
15388 }
15389 arg2 = static_cast< double >(val2);
15390 if (arg1) (arg1)->saturation = arg2;
15391
15392 resultobj = SWIG_Py_Void();
15393 return resultobj;
15394 fail:
15395 return NULL;
15396 }
15397
15398
15399 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15400 PyObject *resultobj = 0;
15401 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15402 double result;
15403 void *argp1 = 0 ;
15404 int res1 = 0 ;
15405 PyObject *swig_obj[1] ;
15406
15407 if (!args) SWIG_fail;
15408 swig_obj[0] = args;
15409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15410 if (!SWIG_IsOK(res1)) {
15411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15412 }
15413 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15414 result = (double) ((arg1)->saturation);
15415 resultobj = SWIG_From_double(static_cast< double >(result));
15416 return resultobj;
15417 fail:
15418 return NULL;
15419 }
15420
15421
15422 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15423 PyObject *resultobj = 0;
15424 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15425 double arg2 ;
15426 void *argp1 = 0 ;
15427 int res1 = 0 ;
15428 double val2 ;
15429 int ecode2 = 0 ;
15430 PyObject *swig_obj[2] ;
15431
15432 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
15433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15434 if (!SWIG_IsOK(res1)) {
15435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15436 }
15437 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15438 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15439 if (!SWIG_IsOK(ecode2)) {
15440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
15441 }
15442 arg2 = static_cast< double >(val2);
15443 if (arg1) (arg1)->value = arg2;
15444
15445 resultobj = SWIG_Py_Void();
15446 return resultobj;
15447 fail:
15448 return NULL;
15449 }
15450
15451
15452 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15453 PyObject *resultobj = 0;
15454 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15455 double result;
15456 void *argp1 = 0 ;
15457 int res1 = 0 ;
15458 PyObject *swig_obj[1] ;
15459
15460 if (!args) SWIG_fail;
15461 swig_obj[0] = args;
15462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15463 if (!SWIG_IsOK(res1)) {
15464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15465 }
15466 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15467 result = (double) ((arg1)->value);
15468 resultobj = SWIG_From_double(static_cast< double >(result));
15469 return resultobj;
15470 fail:
15471 return NULL;
15472 }
15473
15474
15475 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15476 PyObject *obj;
15477 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15478 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
15479 return SWIG_Py_Void();
15480 }
15481
15482 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15483 return SWIG_Python_InitShadowInstance(args);
15484 }
15485
15486 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15487 PyObject *resultobj = 0;
15488 wxString *arg1 = 0 ;
15489 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15490 int arg3 = (int) -1 ;
15491 wxImage *result = 0 ;
15492 bool temp1 = false ;
15493 long val2 ;
15494 int ecode2 = 0 ;
15495 int val3 ;
15496 int ecode3 = 0 ;
15497 PyObject * obj0 = 0 ;
15498 PyObject * obj1 = 0 ;
15499 PyObject * obj2 = 0 ;
15500 char * kwnames[] = {
15501 (char *) "name",(char *) "type",(char *) "index", NULL
15502 };
15503
15504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15505 {
15506 arg1 = wxString_in_helper(obj0);
15507 if (arg1 == NULL) SWIG_fail;
15508 temp1 = true;
15509 }
15510 if (obj1) {
15511 ecode2 = SWIG_AsVal_long(obj1, &val2);
15512 if (!SWIG_IsOK(ecode2)) {
15513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
15514 }
15515 arg2 = static_cast< long >(val2);
15516 }
15517 if (obj2) {
15518 ecode3 = SWIG_AsVal_int(obj2, &val3);
15519 if (!SWIG_IsOK(ecode3)) {
15520 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
15521 }
15522 arg3 = static_cast< int >(val3);
15523 }
15524 {
15525 PyThreadState* __tstate = wxPyBeginAllowThreads();
15526 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
15527 wxPyEndAllowThreads(__tstate);
15528 if (PyErr_Occurred()) SWIG_fail;
15529 }
15530 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
15531 {
15532 if (temp1)
15533 delete arg1;
15534 }
15535 return resultobj;
15536 fail:
15537 {
15538 if (temp1)
15539 delete arg1;
15540 }
15541 return NULL;
15542 }
15543
15544
15545 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15546 PyObject *resultobj = 0;
15547 wxImage *arg1 = (wxImage *) 0 ;
15548 void *argp1 = 0 ;
15549 int res1 = 0 ;
15550 PyObject *swig_obj[1] ;
15551
15552 if (!args) SWIG_fail;
15553 swig_obj[0] = args;
15554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
15555 if (!SWIG_IsOK(res1)) {
15556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
15557 }
15558 arg1 = reinterpret_cast< wxImage * >(argp1);
15559 {
15560 PyThreadState* __tstate = wxPyBeginAllowThreads();
15561 delete arg1;
15562
15563 wxPyEndAllowThreads(__tstate);
15564 if (PyErr_Occurred()) SWIG_fail;
15565 }
15566 resultobj = SWIG_Py_Void();
15567 return resultobj;
15568 fail:
15569 return NULL;
15570 }
15571
15572
15573 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15574 PyObject *resultobj = 0;
15575 wxString *arg1 = 0 ;
15576 wxString *arg2 = 0 ;
15577 int arg3 = (int) -1 ;
15578 wxImage *result = 0 ;
15579 bool temp1 = false ;
15580 bool temp2 = false ;
15581 int val3 ;
15582 int ecode3 = 0 ;
15583 PyObject * obj0 = 0 ;
15584 PyObject * obj1 = 0 ;
15585 PyObject * obj2 = 0 ;
15586 char * kwnames[] = {
15587 (char *) "name",(char *) "mimetype",(char *) "index", NULL
15588 };
15589
15590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15591 {
15592 arg1 = wxString_in_helper(obj0);
15593 if (arg1 == NULL) SWIG_fail;
15594 temp1 = true;
15595 }
15596 {
15597 arg2 = wxString_in_helper(obj1);
15598 if (arg2 == NULL) SWIG_fail;
15599 temp2 = true;
15600 }
15601 if (obj2) {
15602 ecode3 = SWIG_AsVal_int(obj2, &val3);
15603 if (!SWIG_IsOK(ecode3)) {
15604 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
15605 }
15606 arg3 = static_cast< int >(val3);
15607 }
15608 {
15609 PyThreadState* __tstate = wxPyBeginAllowThreads();
15610 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
15611 wxPyEndAllowThreads(__tstate);
15612 if (PyErr_Occurred()) SWIG_fail;
15613 }
15614 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15615 {
15616 if (temp1)
15617 delete arg1;
15618 }
15619 {
15620 if (temp2)
15621 delete arg2;
15622 }
15623 return resultobj;
15624 fail:
15625 {
15626 if (temp1)
15627 delete arg1;
15628 }
15629 {
15630 if (temp2)
15631 delete arg2;
15632 }
15633 return NULL;
15634 }
15635
15636
15637 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15638 PyObject *resultobj = 0;
15639 wxInputStream *arg1 = 0 ;
15640 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15641 int arg3 = (int) -1 ;
15642 wxImage *result = 0 ;
15643 wxPyInputStream *temp1 ;
15644 bool created1 ;
15645 long val2 ;
15646 int ecode2 = 0 ;
15647 int val3 ;
15648 int ecode3 = 0 ;
15649 PyObject * obj0 = 0 ;
15650 PyObject * obj1 = 0 ;
15651 PyObject * obj2 = 0 ;
15652 char * kwnames[] = {
15653 (char *) "stream",(char *) "type",(char *) "index", NULL
15654 };
15655
15656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15657 {
15658 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15659 arg1 = temp1->m_wxis;
15660 created1 = false;
15661 } else {
15662 PyErr_Clear(); // clear the failure of the wxPyConvert above
15663 arg1 = wxPyCBInputStream_create(obj0, false);
15664 if (arg1 == NULL) {
15665 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15666 SWIG_fail;
15667 }
15668 created1 = true;
15669 }
15670 }
15671 if (obj1) {
15672 ecode2 = SWIG_AsVal_long(obj1, &val2);
15673 if (!SWIG_IsOK(ecode2)) {
15674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
15675 }
15676 arg2 = static_cast< long >(val2);
15677 }
15678 if (obj2) {
15679 ecode3 = SWIG_AsVal_int(obj2, &val3);
15680 if (!SWIG_IsOK(ecode3)) {
15681 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
15682 }
15683 arg3 = static_cast< int >(val3);
15684 }
15685 {
15686 PyThreadState* __tstate = wxPyBeginAllowThreads();
15687 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
15688 wxPyEndAllowThreads(__tstate);
15689 if (PyErr_Occurred()) SWIG_fail;
15690 }
15691 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15692 {
15693 if (created1) delete arg1;
15694 }
15695 return resultobj;
15696 fail:
15697 {
15698 if (created1) delete arg1;
15699 }
15700 return NULL;
15701 }
15702
15703
15704 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15705 PyObject *resultobj = 0;
15706 wxInputStream *arg1 = 0 ;
15707 wxString *arg2 = 0 ;
15708 int arg3 = (int) -1 ;
15709 wxImage *result = 0 ;
15710 wxPyInputStream *temp1 ;
15711 bool created1 ;
15712 bool temp2 = false ;
15713 int val3 ;
15714 int ecode3 = 0 ;
15715 PyObject * obj0 = 0 ;
15716 PyObject * obj1 = 0 ;
15717 PyObject * obj2 = 0 ;
15718 char * kwnames[] = {
15719 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
15720 };
15721
15722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15723 {
15724 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15725 arg1 = temp1->m_wxis;
15726 created1 = false;
15727 } else {
15728 PyErr_Clear(); // clear the failure of the wxPyConvert above
15729 arg1 = wxPyCBInputStream_create(obj0, false);
15730 if (arg1 == NULL) {
15731 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15732 SWIG_fail;
15733 }
15734 created1 = true;
15735 }
15736 }
15737 {
15738 arg2 = wxString_in_helper(obj1);
15739 if (arg2 == NULL) SWIG_fail;
15740 temp2 = true;
15741 }
15742 if (obj2) {
15743 ecode3 = SWIG_AsVal_int(obj2, &val3);
15744 if (!SWIG_IsOK(ecode3)) {
15745 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
15746 }
15747 arg3 = static_cast< int >(val3);
15748 }
15749 {
15750 PyThreadState* __tstate = wxPyBeginAllowThreads();
15751 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
15752 wxPyEndAllowThreads(__tstate);
15753 if (PyErr_Occurred()) SWIG_fail;
15754 }
15755 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15756 {
15757 if (created1) delete arg1;
15758 }
15759 {
15760 if (temp2)
15761 delete arg2;
15762 }
15763 return resultobj;
15764 fail:
15765 {
15766 if (created1) delete arg1;
15767 }
15768 {
15769 if (temp2)
15770 delete arg2;
15771 }
15772 return NULL;
15773 }
15774
15775
15776 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15777 PyObject *resultobj = 0;
15778 int arg1 = (int) 0 ;
15779 int arg2 = (int) 0 ;
15780 bool arg3 = (bool) true ;
15781 wxImage *result = 0 ;
15782 int val1 ;
15783 int ecode1 = 0 ;
15784 int val2 ;
15785 int ecode2 = 0 ;
15786 bool val3 ;
15787 int ecode3 = 0 ;
15788 PyObject * obj0 = 0 ;
15789 PyObject * obj1 = 0 ;
15790 PyObject * obj2 = 0 ;
15791 char * kwnames[] = {
15792 (char *) "width",(char *) "height",(char *) "clear", NULL
15793 };
15794
15795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15796 if (obj0) {
15797 ecode1 = SWIG_AsVal_int(obj0, &val1);
15798 if (!SWIG_IsOK(ecode1)) {
15799 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
15800 }
15801 arg1 = static_cast< int >(val1);
15802 }
15803 if (obj1) {
15804 ecode2 = SWIG_AsVal_int(obj1, &val2);
15805 if (!SWIG_IsOK(ecode2)) {
15806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
15807 }
15808 arg2 = static_cast< int >(val2);
15809 }
15810 if (obj2) {
15811 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15812 if (!SWIG_IsOK(ecode3)) {
15813 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
15814 }
15815 arg3 = static_cast< bool >(val3);
15816 }
15817 {
15818 PyThreadState* __tstate = wxPyBeginAllowThreads();
15819 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
15820 wxPyEndAllowThreads(__tstate);
15821 if (PyErr_Occurred()) SWIG_fail;
15822 }
15823 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15824 return resultobj;
15825 fail:
15826 return NULL;
15827 }
15828
15829
15830 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15831 PyObject *resultobj = 0;
15832 wxBitmap *arg1 = 0 ;
15833 wxImage *result = 0 ;
15834 void *argp1 = 0 ;
15835 int res1 = 0 ;
15836 PyObject * obj0 = 0 ;
15837 char * kwnames[] = {
15838 (char *) "bitmap", NULL
15839 };
15840
15841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
15842 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
15843 if (!SWIG_IsOK(res1)) {
15844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15845 }
15846 if (!argp1) {
15847 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15848 }
15849 arg1 = reinterpret_cast< wxBitmap * >(argp1);
15850 {
15851 if (!wxPyCheckForApp()) SWIG_fail;
15852 PyThreadState* __tstate = wxPyBeginAllowThreads();
15853 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
15854 wxPyEndAllowThreads(__tstate);
15855 if (PyErr_Occurred()) SWIG_fail;
15856 }
15857 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15858 return resultobj;
15859 fail:
15860 return NULL;
15861 }
15862
15863
15864 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15865 PyObject *resultobj = 0;
15866 int arg1 ;
15867 int arg2 ;
15868 buffer arg3 ;
15869 int arg4 ;
15870 wxImage *result = 0 ;
15871 int val1 ;
15872 int ecode1 = 0 ;
15873 int val2 ;
15874 int ecode2 = 0 ;
15875 Py_ssize_t temp3 ;
15876 PyObject * obj0 = 0 ;
15877 PyObject * obj1 = 0 ;
15878 PyObject * obj2 = 0 ;
15879 char * kwnames[] = {
15880 (char *) "width",(char *) "height",(char *) "data", NULL
15881 };
15882
15883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15884 ecode1 = SWIG_AsVal_int(obj0, &val1);
15885 if (!SWIG_IsOK(ecode1)) {
15886 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
15887 }
15888 arg1 = static_cast< int >(val1);
15889 ecode2 = SWIG_AsVal_int(obj1, &val2);
15890 if (!SWIG_IsOK(ecode2)) {
15891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
15892 }
15893 arg2 = static_cast< int >(val2);
15894 {
15895 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
15896 arg4 = (int)temp3;
15897 }
15898 {
15899 PyThreadState* __tstate = wxPyBeginAllowThreads();
15900 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
15901 wxPyEndAllowThreads(__tstate);
15902 if (PyErr_Occurred()) SWIG_fail;
15903 }
15904 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15905 return resultobj;
15906 fail:
15907 return NULL;
15908 }
15909
15910
15911 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15912 PyObject *resultobj = 0;
15913 int arg1 ;
15914 int arg2 ;
15915 buffer arg3 ;
15916 int arg4 ;
15917 buffer arg5 ;
15918 int arg6 ;
15919 wxImage *result = 0 ;
15920 int val1 ;
15921 int ecode1 = 0 ;
15922 int val2 ;
15923 int ecode2 = 0 ;
15924 Py_ssize_t temp3 ;
15925 Py_ssize_t temp5 ;
15926 PyObject * obj0 = 0 ;
15927 PyObject * obj1 = 0 ;
15928 PyObject * obj2 = 0 ;
15929 PyObject * obj3 = 0 ;
15930 char * kwnames[] = {
15931 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
15932 };
15933
15934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15935 ecode1 = SWIG_AsVal_int(obj0, &val1);
15936 if (!SWIG_IsOK(ecode1)) {
15937 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
15938 }
15939 arg1 = static_cast< int >(val1);
15940 ecode2 = SWIG_AsVal_int(obj1, &val2);
15941 if (!SWIG_IsOK(ecode2)) {
15942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
15943 }
15944 arg2 = static_cast< int >(val2);
15945 {
15946 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
15947 arg4 = (int)temp3;
15948 }
15949 {
15950 if (obj3 != Py_None) {
15951 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
15952 arg6 = (int)temp5;
15953 }
15954 }
15955 {
15956 PyThreadState* __tstate = wxPyBeginAllowThreads();
15957 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
15958 wxPyEndAllowThreads(__tstate);
15959 if (PyErr_Occurred()) SWIG_fail;
15960 }
15961 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15962 return resultobj;
15963 fail:
15964 return NULL;
15965 }
15966
15967
15968 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15969 PyObject *resultobj = 0;
15970 wxImage *arg1 = (wxImage *) 0 ;
15971 int arg2 ;
15972 int arg3 ;
15973 bool arg4 = (bool) true ;
15974 void *argp1 = 0 ;
15975 int res1 = 0 ;
15976 int val2 ;
15977 int ecode2 = 0 ;
15978 int val3 ;
15979 int ecode3 = 0 ;
15980 bool val4 ;
15981 int ecode4 = 0 ;
15982 PyObject * obj0 = 0 ;
15983 PyObject * obj1 = 0 ;
15984 PyObject * obj2 = 0 ;
15985 PyObject * obj3 = 0 ;
15986 char * kwnames[] = {
15987 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
15988 };
15989
15990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15992 if (!SWIG_IsOK(res1)) {
15993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
15994 }
15995 arg1 = reinterpret_cast< wxImage * >(argp1);
15996 ecode2 = SWIG_AsVal_int(obj1, &val2);
15997 if (!SWIG_IsOK(ecode2)) {
15998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
15999 }
16000 arg2 = static_cast< int >(val2);
16001 ecode3 = SWIG_AsVal_int(obj2, &val3);
16002 if (!SWIG_IsOK(ecode3)) {
16003 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
16004 }
16005 arg3 = static_cast< int >(val3);
16006 if (obj3) {
16007 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16008 if (!SWIG_IsOK(ecode4)) {
16009 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
16010 }
16011 arg4 = static_cast< bool >(val4);
16012 }
16013 {
16014 PyThreadState* __tstate = wxPyBeginAllowThreads();
16015 (arg1)->Create(arg2,arg3,arg4);
16016 wxPyEndAllowThreads(__tstate);
16017 if (PyErr_Occurred()) SWIG_fail;
16018 }
16019 resultobj = SWIG_Py_Void();
16020 return resultobj;
16021 fail:
16022 return NULL;
16023 }
16024
16025
16026 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16027 PyObject *resultobj = 0;
16028 wxImage *arg1 = (wxImage *) 0 ;
16029 void *argp1 = 0 ;
16030 int res1 = 0 ;
16031 PyObject *swig_obj[1] ;
16032
16033 if (!args) SWIG_fail;
16034 swig_obj[0] = args;
16035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16036 if (!SWIG_IsOK(res1)) {
16037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
16038 }
16039 arg1 = reinterpret_cast< wxImage * >(argp1);
16040 {
16041 PyThreadState* __tstate = wxPyBeginAllowThreads();
16042 (arg1)->Destroy();
16043 wxPyEndAllowThreads(__tstate);
16044 if (PyErr_Occurred()) SWIG_fail;
16045 }
16046 resultobj = SWIG_Py_Void();
16047 return resultobj;
16048 fail:
16049 return NULL;
16050 }
16051
16052
16053 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16054 PyObject *resultobj = 0;
16055 wxImage *arg1 = (wxImage *) 0 ;
16056 int arg2 ;
16057 int arg3 ;
16058 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16059 SwigValueWrapper<wxImage > result;
16060 void *argp1 = 0 ;
16061 int res1 = 0 ;
16062 int val2 ;
16063 int ecode2 = 0 ;
16064 int val3 ;
16065 int ecode3 = 0 ;
16066 int val4 ;
16067 int ecode4 = 0 ;
16068 PyObject * obj0 = 0 ;
16069 PyObject * obj1 = 0 ;
16070 PyObject * obj2 = 0 ;
16071 PyObject * obj3 = 0 ;
16072 char * kwnames[] = {
16073 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16074 };
16075
16076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Scale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16078 if (!SWIG_IsOK(res1)) {
16079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
16080 }
16081 arg1 = reinterpret_cast< wxImage * >(argp1);
16082 ecode2 = SWIG_AsVal_int(obj1, &val2);
16083 if (!SWIG_IsOK(ecode2)) {
16084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
16085 }
16086 arg2 = static_cast< int >(val2);
16087 ecode3 = SWIG_AsVal_int(obj2, &val3);
16088 if (!SWIG_IsOK(ecode3)) {
16089 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
16090 }
16091 arg3 = static_cast< int >(val3);
16092 if (obj3) {
16093 ecode4 = SWIG_AsVal_int(obj3, &val4);
16094 if (!SWIG_IsOK(ecode4)) {
16095 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Scale" "', expected argument " "4"" of type '" "int""'");
16096 }
16097 arg4 = static_cast< int >(val4);
16098 }
16099 {
16100 PyThreadState* __tstate = wxPyBeginAllowThreads();
16101 result = (arg1)->Scale(arg2,arg3,arg4);
16102 wxPyEndAllowThreads(__tstate);
16103 if (PyErr_Occurred()) SWIG_fail;
16104 }
16105 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16106 return resultobj;
16107 fail:
16108 return NULL;
16109 }
16110
16111
16112 SWIGINTERN PyObject *_wrap_Image_ResampleBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16113 PyObject *resultobj = 0;
16114 wxImage *arg1 = (wxImage *) 0 ;
16115 int arg2 ;
16116 int arg3 ;
16117 SwigValueWrapper<wxImage > result;
16118 void *argp1 = 0 ;
16119 int res1 = 0 ;
16120 int val2 ;
16121 int ecode2 = 0 ;
16122 int val3 ;
16123 int ecode3 = 0 ;
16124 PyObject * obj0 = 0 ;
16125 PyObject * obj1 = 0 ;
16126 PyObject * obj2 = 0 ;
16127 char * kwnames[] = {
16128 (char *) "self",(char *) "width",(char *) "height", NULL
16129 };
16130
16131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16133 if (!SWIG_IsOK(res1)) {
16134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBox" "', expected argument " "1"" of type '" "wxImage const *""'");
16135 }
16136 arg1 = reinterpret_cast< wxImage * >(argp1);
16137 ecode2 = SWIG_AsVal_int(obj1, &val2);
16138 if (!SWIG_IsOK(ecode2)) {
16139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBox" "', expected argument " "2"" of type '" "int""'");
16140 }
16141 arg2 = static_cast< int >(val2);
16142 ecode3 = SWIG_AsVal_int(obj2, &val3);
16143 if (!SWIG_IsOK(ecode3)) {
16144 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBox" "', expected argument " "3"" of type '" "int""'");
16145 }
16146 arg3 = static_cast< int >(val3);
16147 {
16148 PyThreadState* __tstate = wxPyBeginAllowThreads();
16149 result = ((wxImage const *)arg1)->ResampleBox(arg2,arg3);
16150 wxPyEndAllowThreads(__tstate);
16151 if (PyErr_Occurred()) SWIG_fail;
16152 }
16153 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16154 return resultobj;
16155 fail:
16156 return NULL;
16157 }
16158
16159
16160 SWIGINTERN PyObject *_wrap_Image_ResampleBicubic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16161 PyObject *resultobj = 0;
16162 wxImage *arg1 = (wxImage *) 0 ;
16163 int arg2 ;
16164 int arg3 ;
16165 SwigValueWrapper<wxImage > result;
16166 void *argp1 = 0 ;
16167 int res1 = 0 ;
16168 int val2 ;
16169 int ecode2 = 0 ;
16170 int val3 ;
16171 int ecode3 = 0 ;
16172 PyObject * obj0 = 0 ;
16173 PyObject * obj1 = 0 ;
16174 PyObject * obj2 = 0 ;
16175 char * kwnames[] = {
16176 (char *) "self",(char *) "width",(char *) "height", NULL
16177 };
16178
16179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBicubic",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16181 if (!SWIG_IsOK(res1)) {
16182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBicubic" "', expected argument " "1"" of type '" "wxImage const *""'");
16183 }
16184 arg1 = reinterpret_cast< wxImage * >(argp1);
16185 ecode2 = SWIG_AsVal_int(obj1, &val2);
16186 if (!SWIG_IsOK(ecode2)) {
16187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBicubic" "', expected argument " "2"" of type '" "int""'");
16188 }
16189 arg2 = static_cast< int >(val2);
16190 ecode3 = SWIG_AsVal_int(obj2, &val3);
16191 if (!SWIG_IsOK(ecode3)) {
16192 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBicubic" "', expected argument " "3"" of type '" "int""'");
16193 }
16194 arg3 = static_cast< int >(val3);
16195 {
16196 PyThreadState* __tstate = wxPyBeginAllowThreads();
16197 result = ((wxImage const *)arg1)->ResampleBicubic(arg2,arg3);
16198 wxPyEndAllowThreads(__tstate);
16199 if (PyErr_Occurred()) SWIG_fail;
16200 }
16201 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16202 return resultobj;
16203 fail:
16204 return NULL;
16205 }
16206
16207
16208 SWIGINTERN PyObject *_wrap_Image_Blur(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16209 PyObject *resultobj = 0;
16210 wxImage *arg1 = (wxImage *) 0 ;
16211 int arg2 ;
16212 SwigValueWrapper<wxImage > result;
16213 void *argp1 = 0 ;
16214 int res1 = 0 ;
16215 int val2 ;
16216 int ecode2 = 0 ;
16217 PyObject * obj0 = 0 ;
16218 PyObject * obj1 = 0 ;
16219 char * kwnames[] = {
16220 (char *) "self",(char *) "radius", NULL
16221 };
16222
16223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_Blur",kwnames,&obj0,&obj1)) SWIG_fail;
16224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16225 if (!SWIG_IsOK(res1)) {
16226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Blur" "', expected argument " "1"" of type '" "wxImage *""'");
16227 }
16228 arg1 = reinterpret_cast< wxImage * >(argp1);
16229 ecode2 = SWIG_AsVal_int(obj1, &val2);
16230 if (!SWIG_IsOK(ecode2)) {
16231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Blur" "', expected argument " "2"" of type '" "int""'");
16232 }
16233 arg2 = static_cast< int >(val2);
16234 {
16235 PyThreadState* __tstate = wxPyBeginAllowThreads();
16236 result = (arg1)->Blur(arg2);
16237 wxPyEndAllowThreads(__tstate);
16238 if (PyErr_Occurred()) SWIG_fail;
16239 }
16240 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16241 return resultobj;
16242 fail:
16243 return NULL;
16244 }
16245
16246
16247 SWIGINTERN PyObject *_wrap_Image_BlurHorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16248 PyObject *resultobj = 0;
16249 wxImage *arg1 = (wxImage *) 0 ;
16250 int arg2 ;
16251 SwigValueWrapper<wxImage > result;
16252 void *argp1 = 0 ;
16253 int res1 = 0 ;
16254 int val2 ;
16255 int ecode2 = 0 ;
16256 PyObject * obj0 = 0 ;
16257 PyObject * obj1 = 0 ;
16258 char * kwnames[] = {
16259 (char *) "self",(char *) "radius", NULL
16260 };
16261
16262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurHorizontal",kwnames,&obj0,&obj1)) SWIG_fail;
16263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16264 if (!SWIG_IsOK(res1)) {
16265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurHorizontal" "', expected argument " "1"" of type '" "wxImage *""'");
16266 }
16267 arg1 = reinterpret_cast< wxImage * >(argp1);
16268 ecode2 = SWIG_AsVal_int(obj1, &val2);
16269 if (!SWIG_IsOK(ecode2)) {
16270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurHorizontal" "', expected argument " "2"" of type '" "int""'");
16271 }
16272 arg2 = static_cast< int >(val2);
16273 {
16274 PyThreadState* __tstate = wxPyBeginAllowThreads();
16275 result = (arg1)->BlurHorizontal(arg2);
16276 wxPyEndAllowThreads(__tstate);
16277 if (PyErr_Occurred()) SWIG_fail;
16278 }
16279 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16280 return resultobj;
16281 fail:
16282 return NULL;
16283 }
16284
16285
16286 SWIGINTERN PyObject *_wrap_Image_BlurVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16287 PyObject *resultobj = 0;
16288 wxImage *arg1 = (wxImage *) 0 ;
16289 int arg2 ;
16290 SwigValueWrapper<wxImage > result;
16291 void *argp1 = 0 ;
16292 int res1 = 0 ;
16293 int val2 ;
16294 int ecode2 = 0 ;
16295 PyObject * obj0 = 0 ;
16296 PyObject * obj1 = 0 ;
16297 char * kwnames[] = {
16298 (char *) "self",(char *) "radius", NULL
16299 };
16300
16301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurVertical",kwnames,&obj0,&obj1)) SWIG_fail;
16302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16303 if (!SWIG_IsOK(res1)) {
16304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurVertical" "', expected argument " "1"" of type '" "wxImage *""'");
16305 }
16306 arg1 = reinterpret_cast< wxImage * >(argp1);
16307 ecode2 = SWIG_AsVal_int(obj1, &val2);
16308 if (!SWIG_IsOK(ecode2)) {
16309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurVertical" "', expected argument " "2"" of type '" "int""'");
16310 }
16311 arg2 = static_cast< int >(val2);
16312 {
16313 PyThreadState* __tstate = wxPyBeginAllowThreads();
16314 result = (arg1)->BlurVertical(arg2);
16315 wxPyEndAllowThreads(__tstate);
16316 if (PyErr_Occurred()) SWIG_fail;
16317 }
16318 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16319 return resultobj;
16320 fail:
16321 return NULL;
16322 }
16323
16324
16325 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16326 PyObject *resultobj = 0;
16327 wxImage *arg1 = (wxImage *) 0 ;
16328 int arg2 ;
16329 int arg3 ;
16330 SwigValueWrapper<wxImage > result;
16331 void *argp1 = 0 ;
16332 int res1 = 0 ;
16333 int val2 ;
16334 int ecode2 = 0 ;
16335 int val3 ;
16336 int ecode3 = 0 ;
16337 PyObject * obj0 = 0 ;
16338 PyObject * obj1 = 0 ;
16339 PyObject * obj2 = 0 ;
16340 char * kwnames[] = {
16341 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
16342 };
16343
16344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16346 if (!SWIG_IsOK(res1)) {
16347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
16348 }
16349 arg1 = reinterpret_cast< wxImage * >(argp1);
16350 ecode2 = SWIG_AsVal_int(obj1, &val2);
16351 if (!SWIG_IsOK(ecode2)) {
16352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
16353 }
16354 arg2 = static_cast< int >(val2);
16355 ecode3 = SWIG_AsVal_int(obj2, &val3);
16356 if (!SWIG_IsOK(ecode3)) {
16357 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
16358 }
16359 arg3 = static_cast< int >(val3);
16360 {
16361 PyThreadState* __tstate = wxPyBeginAllowThreads();
16362 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
16363 wxPyEndAllowThreads(__tstate);
16364 if (PyErr_Occurred()) SWIG_fail;
16365 }
16366 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16367 return resultobj;
16368 fail:
16369 return NULL;
16370 }
16371
16372
16373 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16374 PyObject *resultobj = 0;
16375 wxImage *arg1 = (wxImage *) 0 ;
16376 int arg2 ;
16377 int arg3 ;
16378 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16379 wxImage *result = 0 ;
16380 void *argp1 = 0 ;
16381 int res1 = 0 ;
16382 int val2 ;
16383 int ecode2 = 0 ;
16384 int val3 ;
16385 int ecode3 = 0 ;
16386 int val4 ;
16387 int ecode4 = 0 ;
16388 PyObject * obj0 = 0 ;
16389 PyObject * obj1 = 0 ;
16390 PyObject * obj2 = 0 ;
16391 PyObject * obj3 = 0 ;
16392 char * kwnames[] = {
16393 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16394 };
16395
16396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Rescale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16398 if (!SWIG_IsOK(res1)) {
16399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
16400 }
16401 arg1 = reinterpret_cast< wxImage * >(argp1);
16402 ecode2 = SWIG_AsVal_int(obj1, &val2);
16403 if (!SWIG_IsOK(ecode2)) {
16404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
16405 }
16406 arg2 = static_cast< int >(val2);
16407 ecode3 = SWIG_AsVal_int(obj2, &val3);
16408 if (!SWIG_IsOK(ecode3)) {
16409 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
16410 }
16411 arg3 = static_cast< int >(val3);
16412 if (obj3) {
16413 ecode4 = SWIG_AsVal_int(obj3, &val4);
16414 if (!SWIG_IsOK(ecode4)) {
16415 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rescale" "', expected argument " "4"" of type '" "int""'");
16416 }
16417 arg4 = static_cast< int >(val4);
16418 }
16419 {
16420 PyThreadState* __tstate = wxPyBeginAllowThreads();
16421 {
16422 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3,arg4);
16423 result = (wxImage *) &_result_ref;
16424 }
16425 wxPyEndAllowThreads(__tstate);
16426 if (PyErr_Occurred()) SWIG_fail;
16427 }
16428 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16429 return resultobj;
16430 fail:
16431 return NULL;
16432 }
16433
16434
16435 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16436 PyObject *resultobj = 0;
16437 wxImage *arg1 = (wxImage *) 0 ;
16438 wxSize *arg2 = 0 ;
16439 wxPoint *arg3 = 0 ;
16440 int arg4 = (int) -1 ;
16441 int arg5 = (int) -1 ;
16442 int arg6 = (int) -1 ;
16443 wxImage *result = 0 ;
16444 void *argp1 = 0 ;
16445 int res1 = 0 ;
16446 wxSize temp2 ;
16447 wxPoint temp3 ;
16448 int val4 ;
16449 int ecode4 = 0 ;
16450 int val5 ;
16451 int ecode5 = 0 ;
16452 int val6 ;
16453 int ecode6 = 0 ;
16454 PyObject * obj0 = 0 ;
16455 PyObject * obj1 = 0 ;
16456 PyObject * obj2 = 0 ;
16457 PyObject * obj3 = 0 ;
16458 PyObject * obj4 = 0 ;
16459 PyObject * obj5 = 0 ;
16460 char * kwnames[] = {
16461 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
16462 };
16463
16464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16466 if (!SWIG_IsOK(res1)) {
16467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
16468 }
16469 arg1 = reinterpret_cast< wxImage * >(argp1);
16470 {
16471 arg2 = &temp2;
16472 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
16473 }
16474 {
16475 arg3 = &temp3;
16476 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16477 }
16478 if (obj3) {
16479 ecode4 = SWIG_AsVal_int(obj3, &val4);
16480 if (!SWIG_IsOK(ecode4)) {
16481 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
16482 }
16483 arg4 = static_cast< int >(val4);
16484 }
16485 if (obj4) {
16486 ecode5 = SWIG_AsVal_int(obj4, &val5);
16487 if (!SWIG_IsOK(ecode5)) {
16488 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
16489 }
16490 arg5 = static_cast< int >(val5);
16491 }
16492 if (obj5) {
16493 ecode6 = SWIG_AsVal_int(obj5, &val6);
16494 if (!SWIG_IsOK(ecode6)) {
16495 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
16496 }
16497 arg6 = static_cast< int >(val6);
16498 }
16499 {
16500 PyThreadState* __tstate = wxPyBeginAllowThreads();
16501 {
16502 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
16503 result = (wxImage *) &_result_ref;
16504 }
16505 wxPyEndAllowThreads(__tstate);
16506 if (PyErr_Occurred()) SWIG_fail;
16507 }
16508 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16509 return resultobj;
16510 fail:
16511 return NULL;
16512 }
16513
16514
16515 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16516 PyObject *resultobj = 0;
16517 wxImage *arg1 = (wxImage *) 0 ;
16518 int arg2 ;
16519 int arg3 ;
16520 byte arg4 ;
16521 byte arg5 ;
16522 byte arg6 ;
16523 void *argp1 = 0 ;
16524 int res1 = 0 ;
16525 int val2 ;
16526 int ecode2 = 0 ;
16527 int val3 ;
16528 int ecode3 = 0 ;
16529 unsigned char val4 ;
16530 int ecode4 = 0 ;
16531 unsigned char val5 ;
16532 int ecode5 = 0 ;
16533 unsigned char val6 ;
16534 int ecode6 = 0 ;
16535 PyObject * obj0 = 0 ;
16536 PyObject * obj1 = 0 ;
16537 PyObject * obj2 = 0 ;
16538 PyObject * obj3 = 0 ;
16539 PyObject * obj4 = 0 ;
16540 PyObject * obj5 = 0 ;
16541 char * kwnames[] = {
16542 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
16543 };
16544
16545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16547 if (!SWIG_IsOK(res1)) {
16548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
16549 }
16550 arg1 = reinterpret_cast< wxImage * >(argp1);
16551 ecode2 = SWIG_AsVal_int(obj1, &val2);
16552 if (!SWIG_IsOK(ecode2)) {
16553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
16554 }
16555 arg2 = static_cast< int >(val2);
16556 ecode3 = SWIG_AsVal_int(obj2, &val3);
16557 if (!SWIG_IsOK(ecode3)) {
16558 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
16559 }
16560 arg3 = static_cast< int >(val3);
16561 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16562 if (!SWIG_IsOK(ecode4)) {
16563 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
16564 }
16565 arg4 = static_cast< byte >(val4);
16566 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16567 if (!SWIG_IsOK(ecode5)) {
16568 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
16569 }
16570 arg5 = static_cast< byte >(val5);
16571 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16572 if (!SWIG_IsOK(ecode6)) {
16573 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
16574 }
16575 arg6 = static_cast< byte >(val6);
16576 {
16577 PyThreadState* __tstate = wxPyBeginAllowThreads();
16578 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
16579 wxPyEndAllowThreads(__tstate);
16580 if (PyErr_Occurred()) SWIG_fail;
16581 }
16582 resultobj = SWIG_Py_Void();
16583 return resultobj;
16584 fail:
16585 return NULL;
16586 }
16587
16588
16589 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16590 PyObject *resultobj = 0;
16591 wxImage *arg1 = (wxImage *) 0 ;
16592 wxRect *arg2 = 0 ;
16593 byte arg3 ;
16594 byte arg4 ;
16595 byte arg5 ;
16596 void *argp1 = 0 ;
16597 int res1 = 0 ;
16598 wxRect temp2 ;
16599 unsigned char val3 ;
16600 int ecode3 = 0 ;
16601 unsigned char val4 ;
16602 int ecode4 = 0 ;
16603 unsigned char val5 ;
16604 int ecode5 = 0 ;
16605 PyObject * obj0 = 0 ;
16606 PyObject * obj1 = 0 ;
16607 PyObject * obj2 = 0 ;
16608 PyObject * obj3 = 0 ;
16609 PyObject * obj4 = 0 ;
16610 char * kwnames[] = {
16611 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
16612 };
16613
16614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16616 if (!SWIG_IsOK(res1)) {
16617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
16618 }
16619 arg1 = reinterpret_cast< wxImage * >(argp1);
16620 {
16621 arg2 = &temp2;
16622 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
16623 }
16624 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16625 if (!SWIG_IsOK(ecode3)) {
16626 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
16627 }
16628 arg3 = static_cast< byte >(val3);
16629 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16630 if (!SWIG_IsOK(ecode4)) {
16631 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
16632 }
16633 arg4 = static_cast< byte >(val4);
16634 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16635 if (!SWIG_IsOK(ecode5)) {
16636 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
16637 }
16638 arg5 = static_cast< byte >(val5);
16639 {
16640 PyThreadState* __tstate = wxPyBeginAllowThreads();
16641 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
16642 wxPyEndAllowThreads(__tstate);
16643 if (PyErr_Occurred()) SWIG_fail;
16644 }
16645 resultobj = SWIG_Py_Void();
16646 return resultobj;
16647 fail:
16648 return NULL;
16649 }
16650
16651
16652 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16653 PyObject *resultobj = 0;
16654 wxImage *arg1 = (wxImage *) 0 ;
16655 int arg2 ;
16656 int arg3 ;
16657 byte result;
16658 void *argp1 = 0 ;
16659 int res1 = 0 ;
16660 int val2 ;
16661 int ecode2 = 0 ;
16662 int val3 ;
16663 int ecode3 = 0 ;
16664 PyObject * obj0 = 0 ;
16665 PyObject * obj1 = 0 ;
16666 PyObject * obj2 = 0 ;
16667 char * kwnames[] = {
16668 (char *) "self",(char *) "x",(char *) "y", NULL
16669 };
16670
16671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16673 if (!SWIG_IsOK(res1)) {
16674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
16675 }
16676 arg1 = reinterpret_cast< wxImage * >(argp1);
16677 ecode2 = SWIG_AsVal_int(obj1, &val2);
16678 if (!SWIG_IsOK(ecode2)) {
16679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
16680 }
16681 arg2 = static_cast< int >(val2);
16682 ecode3 = SWIG_AsVal_int(obj2, &val3);
16683 if (!SWIG_IsOK(ecode3)) {
16684 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
16685 }
16686 arg3 = static_cast< int >(val3);
16687 {
16688 PyThreadState* __tstate = wxPyBeginAllowThreads();
16689 result = (byte)(arg1)->GetRed(arg2,arg3);
16690 wxPyEndAllowThreads(__tstate);
16691 if (PyErr_Occurred()) SWIG_fail;
16692 }
16693 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16694 return resultobj;
16695 fail:
16696 return NULL;
16697 }
16698
16699
16700 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16701 PyObject *resultobj = 0;
16702 wxImage *arg1 = (wxImage *) 0 ;
16703 int arg2 ;
16704 int arg3 ;
16705 byte result;
16706 void *argp1 = 0 ;
16707 int res1 = 0 ;
16708 int val2 ;
16709 int ecode2 = 0 ;
16710 int val3 ;
16711 int ecode3 = 0 ;
16712 PyObject * obj0 = 0 ;
16713 PyObject * obj1 = 0 ;
16714 PyObject * obj2 = 0 ;
16715 char * kwnames[] = {
16716 (char *) "self",(char *) "x",(char *) "y", NULL
16717 };
16718
16719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16721 if (!SWIG_IsOK(res1)) {
16722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
16723 }
16724 arg1 = reinterpret_cast< wxImage * >(argp1);
16725 ecode2 = SWIG_AsVal_int(obj1, &val2);
16726 if (!SWIG_IsOK(ecode2)) {
16727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
16728 }
16729 arg2 = static_cast< int >(val2);
16730 ecode3 = SWIG_AsVal_int(obj2, &val3);
16731 if (!SWIG_IsOK(ecode3)) {
16732 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
16733 }
16734 arg3 = static_cast< int >(val3);
16735 {
16736 PyThreadState* __tstate = wxPyBeginAllowThreads();
16737 result = (byte)(arg1)->GetGreen(arg2,arg3);
16738 wxPyEndAllowThreads(__tstate);
16739 if (PyErr_Occurred()) SWIG_fail;
16740 }
16741 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16742 return resultobj;
16743 fail:
16744 return NULL;
16745 }
16746
16747
16748 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16749 PyObject *resultobj = 0;
16750 wxImage *arg1 = (wxImage *) 0 ;
16751 int arg2 ;
16752 int arg3 ;
16753 byte result;
16754 void *argp1 = 0 ;
16755 int res1 = 0 ;
16756 int val2 ;
16757 int ecode2 = 0 ;
16758 int val3 ;
16759 int ecode3 = 0 ;
16760 PyObject * obj0 = 0 ;
16761 PyObject * obj1 = 0 ;
16762 PyObject * obj2 = 0 ;
16763 char * kwnames[] = {
16764 (char *) "self",(char *) "x",(char *) "y", NULL
16765 };
16766
16767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16769 if (!SWIG_IsOK(res1)) {
16770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
16771 }
16772 arg1 = reinterpret_cast< wxImage * >(argp1);
16773 ecode2 = SWIG_AsVal_int(obj1, &val2);
16774 if (!SWIG_IsOK(ecode2)) {
16775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
16776 }
16777 arg2 = static_cast< int >(val2);
16778 ecode3 = SWIG_AsVal_int(obj2, &val3);
16779 if (!SWIG_IsOK(ecode3)) {
16780 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
16781 }
16782 arg3 = static_cast< int >(val3);
16783 {
16784 PyThreadState* __tstate = wxPyBeginAllowThreads();
16785 result = (byte)(arg1)->GetBlue(arg2,arg3);
16786 wxPyEndAllowThreads(__tstate);
16787 if (PyErr_Occurred()) SWIG_fail;
16788 }
16789 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16790 return resultobj;
16791 fail:
16792 return NULL;
16793 }
16794
16795
16796 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16797 PyObject *resultobj = 0;
16798 wxImage *arg1 = (wxImage *) 0 ;
16799 int arg2 ;
16800 int arg3 ;
16801 byte arg4 ;
16802 void *argp1 = 0 ;
16803 int res1 = 0 ;
16804 int val2 ;
16805 int ecode2 = 0 ;
16806 int val3 ;
16807 int ecode3 = 0 ;
16808 unsigned char val4 ;
16809 int ecode4 = 0 ;
16810 PyObject * obj0 = 0 ;
16811 PyObject * obj1 = 0 ;
16812 PyObject * obj2 = 0 ;
16813 PyObject * obj3 = 0 ;
16814 char * kwnames[] = {
16815 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
16816 };
16817
16818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16820 if (!SWIG_IsOK(res1)) {
16821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16822 }
16823 arg1 = reinterpret_cast< wxImage * >(argp1);
16824 ecode2 = SWIG_AsVal_int(obj1, &val2);
16825 if (!SWIG_IsOK(ecode2)) {
16826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
16827 }
16828 arg2 = static_cast< int >(val2);
16829 ecode3 = SWIG_AsVal_int(obj2, &val3);
16830 if (!SWIG_IsOK(ecode3)) {
16831 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
16832 }
16833 arg3 = static_cast< int >(val3);
16834 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16835 if (!SWIG_IsOK(ecode4)) {
16836 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
16837 }
16838 arg4 = static_cast< byte >(val4);
16839 {
16840 PyThreadState* __tstate = wxPyBeginAllowThreads();
16841 (arg1)->SetAlpha(arg2,arg3,arg4);
16842 wxPyEndAllowThreads(__tstate);
16843 if (PyErr_Occurred()) SWIG_fail;
16844 }
16845 resultobj = SWIG_Py_Void();
16846 return resultobj;
16847 fail:
16848 return NULL;
16849 }
16850
16851
16852 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16853 PyObject *resultobj = 0;
16854 wxImage *arg1 = (wxImage *) 0 ;
16855 int arg2 ;
16856 int arg3 ;
16857 byte result;
16858 void *argp1 = 0 ;
16859 int res1 = 0 ;
16860 int val2 ;
16861 int ecode2 = 0 ;
16862 int val3 ;
16863 int ecode3 = 0 ;
16864 PyObject * obj0 = 0 ;
16865 PyObject * obj1 = 0 ;
16866 PyObject * obj2 = 0 ;
16867 char * kwnames[] = {
16868 (char *) "self",(char *) "x",(char *) "y", NULL
16869 };
16870
16871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16873 if (!SWIG_IsOK(res1)) {
16874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16875 }
16876 arg1 = reinterpret_cast< wxImage * >(argp1);
16877 ecode2 = SWIG_AsVal_int(obj1, &val2);
16878 if (!SWIG_IsOK(ecode2)) {
16879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
16880 }
16881 arg2 = static_cast< int >(val2);
16882 ecode3 = SWIG_AsVal_int(obj2, &val3);
16883 if (!SWIG_IsOK(ecode3)) {
16884 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
16885 }
16886 arg3 = static_cast< int >(val3);
16887 {
16888 PyThreadState* __tstate = wxPyBeginAllowThreads();
16889 result = (byte)(arg1)->GetAlpha(arg2,arg3);
16890 wxPyEndAllowThreads(__tstate);
16891 if (PyErr_Occurred()) SWIG_fail;
16892 }
16893 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16894 return resultobj;
16895 fail:
16896 return NULL;
16897 }
16898
16899
16900 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16901 PyObject *resultobj = 0;
16902 wxImage *arg1 = (wxImage *) 0 ;
16903 bool result;
16904 void *argp1 = 0 ;
16905 int res1 = 0 ;
16906 PyObject *swig_obj[1] ;
16907
16908 if (!args) SWIG_fail;
16909 swig_obj[0] = args;
16910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16911 if (!SWIG_IsOK(res1)) {
16912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16913 }
16914 arg1 = reinterpret_cast< wxImage * >(argp1);
16915 {
16916 PyThreadState* __tstate = wxPyBeginAllowThreads();
16917 result = (bool)(arg1)->HasAlpha();
16918 wxPyEndAllowThreads(__tstate);
16919 if (PyErr_Occurred()) SWIG_fail;
16920 }
16921 {
16922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16923 }
16924 return resultobj;
16925 fail:
16926 return NULL;
16927 }
16928
16929
16930 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16931 PyObject *resultobj = 0;
16932 wxImage *arg1 = (wxImage *) 0 ;
16933 void *argp1 = 0 ;
16934 int res1 = 0 ;
16935 PyObject *swig_obj[1] ;
16936
16937 if (!args) SWIG_fail;
16938 swig_obj[0] = args;
16939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16940 if (!SWIG_IsOK(res1)) {
16941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16942 }
16943 arg1 = reinterpret_cast< wxImage * >(argp1);
16944 {
16945 PyThreadState* __tstate = wxPyBeginAllowThreads();
16946 (arg1)->InitAlpha();
16947 wxPyEndAllowThreads(__tstate);
16948 if (PyErr_Occurred()) SWIG_fail;
16949 }
16950 resultobj = SWIG_Py_Void();
16951 return resultobj;
16952 fail:
16953 return NULL;
16954 }
16955
16956
16957 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16958 PyObject *resultobj = 0;
16959 wxImage *arg1 = (wxImage *) 0 ;
16960 int arg2 ;
16961 int arg3 ;
16962 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
16963 bool result;
16964 void *argp1 = 0 ;
16965 int res1 = 0 ;
16966 int val2 ;
16967 int ecode2 = 0 ;
16968 int val3 ;
16969 int ecode3 = 0 ;
16970 unsigned char val4 ;
16971 int ecode4 = 0 ;
16972 PyObject * obj0 = 0 ;
16973 PyObject * obj1 = 0 ;
16974 PyObject * obj2 = 0 ;
16975 PyObject * obj3 = 0 ;
16976 char * kwnames[] = {
16977 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
16978 };
16979
16980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16982 if (!SWIG_IsOK(res1)) {
16983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
16984 }
16985 arg1 = reinterpret_cast< wxImage * >(argp1);
16986 ecode2 = SWIG_AsVal_int(obj1, &val2);
16987 if (!SWIG_IsOK(ecode2)) {
16988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
16989 }
16990 arg2 = static_cast< int >(val2);
16991 ecode3 = SWIG_AsVal_int(obj2, &val3);
16992 if (!SWIG_IsOK(ecode3)) {
16993 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
16994 }
16995 arg3 = static_cast< int >(val3);
16996 if (obj3) {
16997 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16998 if (!SWIG_IsOK(ecode4)) {
16999 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
17000 }
17001 arg4 = static_cast< byte >(val4);
17002 }
17003 {
17004 PyThreadState* __tstate = wxPyBeginAllowThreads();
17005 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
17006 wxPyEndAllowThreads(__tstate);
17007 if (PyErr_Occurred()) SWIG_fail;
17008 }
17009 {
17010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17011 }
17012 return resultobj;
17013 fail:
17014 return NULL;
17015 }
17016
17017
17018 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17019 PyObject *resultobj = 0;
17020 wxImage *arg1 = (wxImage *) 0 ;
17021 byte *arg2 = (byte *) 0 ;
17022 byte *arg3 = (byte *) 0 ;
17023 byte *arg4 = (byte *) 0 ;
17024 byte arg5 = (byte) 0 ;
17025 byte arg6 = (byte) 0 ;
17026 byte arg7 = (byte) 0 ;
17027 bool result;
17028 void *argp1 = 0 ;
17029 int res1 = 0 ;
17030 byte temp2 ;
17031 int res2 = SWIG_TMPOBJ ;
17032 byte temp3 ;
17033 int res3 = SWIG_TMPOBJ ;
17034 byte temp4 ;
17035 int res4 = SWIG_TMPOBJ ;
17036 unsigned char val5 ;
17037 int ecode5 = 0 ;
17038 unsigned char val6 ;
17039 int ecode6 = 0 ;
17040 unsigned char val7 ;
17041 int ecode7 = 0 ;
17042 PyObject * obj0 = 0 ;
17043 PyObject * obj1 = 0 ;
17044 PyObject * obj2 = 0 ;
17045 PyObject * obj3 = 0 ;
17046 char * kwnames[] = {
17047 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
17048 };
17049
17050 arg2 = &temp2;
17051 arg3 = &temp3;
17052 arg4 = &temp4;
17053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17055 if (!SWIG_IsOK(res1)) {
17056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
17057 }
17058 arg1 = reinterpret_cast< wxImage * >(argp1);
17059 if (obj1) {
17060 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
17061 if (!SWIG_IsOK(ecode5)) {
17062 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
17063 }
17064 arg5 = static_cast< byte >(val5);
17065 }
17066 if (obj2) {
17067 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
17068 if (!SWIG_IsOK(ecode6)) {
17069 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
17070 }
17071 arg6 = static_cast< byte >(val6);
17072 }
17073 if (obj3) {
17074 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
17075 if (!SWIG_IsOK(ecode7)) {
17076 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
17077 }
17078 arg7 = static_cast< byte >(val7);
17079 }
17080 {
17081 PyThreadState* __tstate = wxPyBeginAllowThreads();
17082 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
17083 wxPyEndAllowThreads(__tstate);
17084 if (PyErr_Occurred()) SWIG_fail;
17085 }
17086 {
17087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17088 }
17089 if (SWIG_IsTmpObj(res2)) {
17090 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
17091 } else {
17092 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17093 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
17094 }
17095 if (SWIG_IsTmpObj(res3)) {
17096 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
17097 } else {
17098 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17099 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
17100 }
17101 if (SWIG_IsTmpObj(res4)) {
17102 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
17103 } else {
17104 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17105 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
17106 }
17107 return resultobj;
17108 fail:
17109 return NULL;
17110 }
17111
17112
17113 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17114 PyObject *resultobj = 0;
17115 wxImage *arg1 = (wxImage *) 0 ;
17116 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
17117 bool result;
17118 void *argp1 = 0 ;
17119 int res1 = 0 ;
17120 unsigned char val2 ;
17121 int ecode2 = 0 ;
17122 PyObject * obj0 = 0 ;
17123 PyObject * obj1 = 0 ;
17124 char * kwnames[] = {
17125 (char *) "self",(char *) "threshold", NULL
17126 };
17127
17128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
17129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17130 if (!SWIG_IsOK(res1)) {
17131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
17132 }
17133 arg1 = reinterpret_cast< wxImage * >(argp1);
17134 if (obj1) {
17135 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17136 if (!SWIG_IsOK(ecode2)) {
17137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
17138 }
17139 arg2 = static_cast< byte >(val2);
17140 }
17141 {
17142 PyThreadState* __tstate = wxPyBeginAllowThreads();
17143 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
17144 wxPyEndAllowThreads(__tstate);
17145 if (PyErr_Occurred()) SWIG_fail;
17146 }
17147 {
17148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17149 }
17150 return resultobj;
17151 fail:
17152 return NULL;
17153 }
17154
17155
17156 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17157 PyObject *resultobj = 0;
17158 wxImage *arg1 = (wxImage *) 0 ;
17159 byte arg2 ;
17160 byte arg3 ;
17161 byte arg4 ;
17162 bool result;
17163 void *argp1 = 0 ;
17164 int res1 = 0 ;
17165 unsigned char val2 ;
17166 int ecode2 = 0 ;
17167 unsigned char val3 ;
17168 int ecode3 = 0 ;
17169 unsigned char val4 ;
17170 int ecode4 = 0 ;
17171 PyObject * obj0 = 0 ;
17172 PyObject * obj1 = 0 ;
17173 PyObject * obj2 = 0 ;
17174 PyObject * obj3 = 0 ;
17175 char * kwnames[] = {
17176 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
17177 };
17178
17179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17181 if (!SWIG_IsOK(res1)) {
17182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17183 }
17184 arg1 = reinterpret_cast< wxImage * >(argp1);
17185 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17186 if (!SWIG_IsOK(ecode2)) {
17187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
17188 }
17189 arg2 = static_cast< byte >(val2);
17190 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17191 if (!SWIG_IsOK(ecode3)) {
17192 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
17193 }
17194 arg3 = static_cast< byte >(val3);
17195 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17196 if (!SWIG_IsOK(ecode4)) {
17197 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
17198 }
17199 arg4 = static_cast< byte >(val4);
17200 {
17201 PyThreadState* __tstate = wxPyBeginAllowThreads();
17202 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
17203 wxPyEndAllowThreads(__tstate);
17204 if (PyErr_Occurred()) SWIG_fail;
17205 }
17206 {
17207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17208 }
17209 return resultobj;
17210 fail:
17211 return NULL;
17212 }
17213
17214
17215 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17216 PyObject *resultobj = 0;
17217 wxImage *arg1 = (wxImage *) 0 ;
17218 wxImage *arg2 = 0 ;
17219 byte arg3 ;
17220 byte arg4 ;
17221 byte arg5 ;
17222 bool result;
17223 void *argp1 = 0 ;
17224 int res1 = 0 ;
17225 void *argp2 = 0 ;
17226 int res2 = 0 ;
17227 unsigned char val3 ;
17228 int ecode3 = 0 ;
17229 unsigned char val4 ;
17230 int ecode4 = 0 ;
17231 unsigned char val5 ;
17232 int ecode5 = 0 ;
17233 PyObject * obj0 = 0 ;
17234 PyObject * obj1 = 0 ;
17235 PyObject * obj2 = 0 ;
17236 PyObject * obj3 = 0 ;
17237 PyObject * obj4 = 0 ;
17238 char * kwnames[] = {
17239 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
17240 };
17241
17242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17244 if (!SWIG_IsOK(res1)) {
17245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
17246 }
17247 arg1 = reinterpret_cast< wxImage * >(argp1);
17248 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
17249 if (!SWIG_IsOK(res2)) {
17250 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17251 }
17252 if (!argp2) {
17253 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17254 }
17255 arg2 = reinterpret_cast< wxImage * >(argp2);
17256 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17257 if (!SWIG_IsOK(ecode3)) {
17258 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
17259 }
17260 arg3 = static_cast< byte >(val3);
17261 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17262 if (!SWIG_IsOK(ecode4)) {
17263 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
17264 }
17265 arg4 = static_cast< byte >(val4);
17266 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
17267 if (!SWIG_IsOK(ecode5)) {
17268 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
17269 }
17270 arg5 = static_cast< byte >(val5);
17271 {
17272 PyThreadState* __tstate = wxPyBeginAllowThreads();
17273 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
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_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17287 PyObject *resultobj = 0;
17288 wxString *arg1 = 0 ;
17289 bool result;
17290 bool temp1 = false ;
17291 PyObject * obj0 = 0 ;
17292 char * kwnames[] = {
17293 (char *) "filename", NULL
17294 };
17295
17296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
17297 {
17298 arg1 = wxString_in_helper(obj0);
17299 if (arg1 == NULL) SWIG_fail;
17300 temp1 = true;
17301 }
17302 {
17303 PyThreadState* __tstate = wxPyBeginAllowThreads();
17304 result = (bool)wxImage::CanRead((wxString const &)*arg1);
17305 wxPyEndAllowThreads(__tstate);
17306 if (PyErr_Occurred()) SWIG_fail;
17307 }
17308 {
17309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17310 }
17311 {
17312 if (temp1)
17313 delete arg1;
17314 }
17315 return resultobj;
17316 fail:
17317 {
17318 if (temp1)
17319 delete arg1;
17320 }
17321 return NULL;
17322 }
17323
17324
17325 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17326 PyObject *resultobj = 0;
17327 wxString *arg1 = 0 ;
17328 long arg2 = (long) wxBITMAP_TYPE_ANY ;
17329 int result;
17330 bool temp1 = false ;
17331 long val2 ;
17332 int ecode2 = 0 ;
17333 PyObject * obj0 = 0 ;
17334 PyObject * obj1 = 0 ;
17335 char * kwnames[] = {
17336 (char *) "filename",(char *) "type", NULL
17337 };
17338
17339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
17340 {
17341 arg1 = wxString_in_helper(obj0);
17342 if (arg1 == NULL) SWIG_fail;
17343 temp1 = true;
17344 }
17345 if (obj1) {
17346 ecode2 = SWIG_AsVal_long(obj1, &val2);
17347 if (!SWIG_IsOK(ecode2)) {
17348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
17349 }
17350 arg2 = static_cast< long >(val2);
17351 }
17352 {
17353 PyThreadState* __tstate = wxPyBeginAllowThreads();
17354 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
17355 wxPyEndAllowThreads(__tstate);
17356 if (PyErr_Occurred()) SWIG_fail;
17357 }
17358 resultobj = SWIG_From_int(static_cast< int >(result));
17359 {
17360 if (temp1)
17361 delete arg1;
17362 }
17363 return resultobj;
17364 fail:
17365 {
17366 if (temp1)
17367 delete arg1;
17368 }
17369 return NULL;
17370 }
17371
17372
17373 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17374 PyObject *resultobj = 0;
17375 wxImage *arg1 = (wxImage *) 0 ;
17376 wxString *arg2 = 0 ;
17377 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17378 int arg4 = (int) -1 ;
17379 bool result;
17380 void *argp1 = 0 ;
17381 int res1 = 0 ;
17382 bool temp2 = false ;
17383 long val3 ;
17384 int ecode3 = 0 ;
17385 int val4 ;
17386 int ecode4 = 0 ;
17387 PyObject * obj0 = 0 ;
17388 PyObject * obj1 = 0 ;
17389 PyObject * obj2 = 0 ;
17390 PyObject * obj3 = 0 ;
17391 char * kwnames[] = {
17392 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
17393 };
17394
17395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17397 if (!SWIG_IsOK(res1)) {
17398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
17399 }
17400 arg1 = reinterpret_cast< wxImage * >(argp1);
17401 {
17402 arg2 = wxString_in_helper(obj1);
17403 if (arg2 == NULL) SWIG_fail;
17404 temp2 = true;
17405 }
17406 if (obj2) {
17407 ecode3 = SWIG_AsVal_long(obj2, &val3);
17408 if (!SWIG_IsOK(ecode3)) {
17409 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
17410 }
17411 arg3 = static_cast< long >(val3);
17412 }
17413 if (obj3) {
17414 ecode4 = SWIG_AsVal_int(obj3, &val4);
17415 if (!SWIG_IsOK(ecode4)) {
17416 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
17417 }
17418 arg4 = static_cast< int >(val4);
17419 }
17420 {
17421 PyThreadState* __tstate = wxPyBeginAllowThreads();
17422 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
17423 wxPyEndAllowThreads(__tstate);
17424 if (PyErr_Occurred()) SWIG_fail;
17425 }
17426 {
17427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17428 }
17429 {
17430 if (temp2)
17431 delete arg2;
17432 }
17433 return resultobj;
17434 fail:
17435 {
17436 if (temp2)
17437 delete arg2;
17438 }
17439 return NULL;
17440 }
17441
17442
17443 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17444 PyObject *resultobj = 0;
17445 wxImage *arg1 = (wxImage *) 0 ;
17446 wxString *arg2 = 0 ;
17447 wxString *arg3 = 0 ;
17448 int arg4 = (int) -1 ;
17449 bool result;
17450 void *argp1 = 0 ;
17451 int res1 = 0 ;
17452 bool temp2 = false ;
17453 bool temp3 = false ;
17454 int val4 ;
17455 int ecode4 = 0 ;
17456 PyObject * obj0 = 0 ;
17457 PyObject * obj1 = 0 ;
17458 PyObject * obj2 = 0 ;
17459 PyObject * obj3 = 0 ;
17460 char * kwnames[] = {
17461 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
17462 };
17463
17464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17466 if (!SWIG_IsOK(res1)) {
17467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17468 }
17469 arg1 = reinterpret_cast< wxImage * >(argp1);
17470 {
17471 arg2 = wxString_in_helper(obj1);
17472 if (arg2 == NULL) SWIG_fail;
17473 temp2 = true;
17474 }
17475 {
17476 arg3 = wxString_in_helper(obj2);
17477 if (arg3 == NULL) SWIG_fail;
17478 temp3 = true;
17479 }
17480 if (obj3) {
17481 ecode4 = SWIG_AsVal_int(obj3, &val4);
17482 if (!SWIG_IsOK(ecode4)) {
17483 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
17484 }
17485 arg4 = static_cast< int >(val4);
17486 }
17487 {
17488 PyThreadState* __tstate = wxPyBeginAllowThreads();
17489 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17490 wxPyEndAllowThreads(__tstate);
17491 if (PyErr_Occurred()) SWIG_fail;
17492 }
17493 {
17494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17495 }
17496 {
17497 if (temp2)
17498 delete arg2;
17499 }
17500 {
17501 if (temp3)
17502 delete arg3;
17503 }
17504 return resultobj;
17505 fail:
17506 {
17507 if (temp2)
17508 delete arg2;
17509 }
17510 {
17511 if (temp3)
17512 delete arg3;
17513 }
17514 return NULL;
17515 }
17516
17517
17518 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17519 PyObject *resultobj = 0;
17520 wxImage *arg1 = (wxImage *) 0 ;
17521 wxString *arg2 = 0 ;
17522 int arg3 ;
17523 bool result;
17524 void *argp1 = 0 ;
17525 int res1 = 0 ;
17526 bool temp2 = false ;
17527 int val3 ;
17528 int ecode3 = 0 ;
17529 PyObject * obj0 = 0 ;
17530 PyObject * obj1 = 0 ;
17531 PyObject * obj2 = 0 ;
17532 char * kwnames[] = {
17533 (char *) "self",(char *) "name",(char *) "type", NULL
17534 };
17535
17536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17538 if (!SWIG_IsOK(res1)) {
17539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
17540 }
17541 arg1 = reinterpret_cast< wxImage * >(argp1);
17542 {
17543 arg2 = wxString_in_helper(obj1);
17544 if (arg2 == NULL) SWIG_fail;
17545 temp2 = true;
17546 }
17547 ecode3 = SWIG_AsVal_int(obj2, &val3);
17548 if (!SWIG_IsOK(ecode3)) {
17549 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
17550 }
17551 arg3 = static_cast< int >(val3);
17552 {
17553 PyThreadState* __tstate = wxPyBeginAllowThreads();
17554 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
17555 wxPyEndAllowThreads(__tstate);
17556 if (PyErr_Occurred()) SWIG_fail;
17557 }
17558 {
17559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17560 }
17561 {
17562 if (temp2)
17563 delete arg2;
17564 }
17565 return resultobj;
17566 fail:
17567 {
17568 if (temp2)
17569 delete arg2;
17570 }
17571 return NULL;
17572 }
17573
17574
17575 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17576 PyObject *resultobj = 0;
17577 wxImage *arg1 = (wxImage *) 0 ;
17578 wxString *arg2 = 0 ;
17579 wxString *arg3 = 0 ;
17580 bool result;
17581 void *argp1 = 0 ;
17582 int res1 = 0 ;
17583 bool temp2 = false ;
17584 bool temp3 = false ;
17585 PyObject * obj0 = 0 ;
17586 PyObject * obj1 = 0 ;
17587 PyObject * obj2 = 0 ;
17588 char * kwnames[] = {
17589 (char *) "self",(char *) "name",(char *) "mimetype", NULL
17590 };
17591
17592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17594 if (!SWIG_IsOK(res1)) {
17595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17596 }
17597 arg1 = reinterpret_cast< wxImage * >(argp1);
17598 {
17599 arg2 = wxString_in_helper(obj1);
17600 if (arg2 == NULL) SWIG_fail;
17601 temp2 = true;
17602 }
17603 {
17604 arg3 = wxString_in_helper(obj2);
17605 if (arg3 == NULL) SWIG_fail;
17606 temp3 = true;
17607 }
17608 {
17609 PyThreadState* __tstate = wxPyBeginAllowThreads();
17610 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
17611 wxPyEndAllowThreads(__tstate);
17612 if (PyErr_Occurred()) SWIG_fail;
17613 }
17614 {
17615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17616 }
17617 {
17618 if (temp2)
17619 delete arg2;
17620 }
17621 {
17622 if (temp3)
17623 delete arg3;
17624 }
17625 return resultobj;
17626 fail:
17627 {
17628 if (temp2)
17629 delete arg2;
17630 }
17631 {
17632 if (temp3)
17633 delete arg3;
17634 }
17635 return NULL;
17636 }
17637
17638
17639 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17640 PyObject *resultobj = 0;
17641 wxInputStream *arg1 = 0 ;
17642 bool result;
17643 wxPyInputStream *temp1 ;
17644 bool created1 ;
17645 PyObject * obj0 = 0 ;
17646 char * kwnames[] = {
17647 (char *) "stream", NULL
17648 };
17649
17650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
17651 {
17652 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
17653 arg1 = temp1->m_wxis;
17654 created1 = false;
17655 } else {
17656 PyErr_Clear(); // clear the failure of the wxPyConvert above
17657 arg1 = wxPyCBInputStream_create(obj0, false);
17658 if (arg1 == NULL) {
17659 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17660 SWIG_fail;
17661 }
17662 created1 = true;
17663 }
17664 }
17665 {
17666 PyThreadState* __tstate = wxPyBeginAllowThreads();
17667 result = (bool)wxImage::CanRead(*arg1);
17668 wxPyEndAllowThreads(__tstate);
17669 if (PyErr_Occurred()) SWIG_fail;
17670 }
17671 {
17672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17673 }
17674 {
17675 if (created1) delete arg1;
17676 }
17677 return resultobj;
17678 fail:
17679 {
17680 if (created1) delete arg1;
17681 }
17682 return NULL;
17683 }
17684
17685
17686 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17687 PyObject *resultobj = 0;
17688 wxImage *arg1 = (wxImage *) 0 ;
17689 wxInputStream *arg2 = 0 ;
17690 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17691 int arg4 = (int) -1 ;
17692 bool result;
17693 void *argp1 = 0 ;
17694 int res1 = 0 ;
17695 wxPyInputStream *temp2 ;
17696 bool created2 ;
17697 long val3 ;
17698 int ecode3 = 0 ;
17699 int val4 ;
17700 int ecode4 = 0 ;
17701 PyObject * obj0 = 0 ;
17702 PyObject * obj1 = 0 ;
17703 PyObject * obj2 = 0 ;
17704 PyObject * obj3 = 0 ;
17705 char * kwnames[] = {
17706 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
17707 };
17708
17709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17711 if (!SWIG_IsOK(res1)) {
17712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
17713 }
17714 arg1 = reinterpret_cast< wxImage * >(argp1);
17715 {
17716 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17717 arg2 = temp2->m_wxis;
17718 created2 = false;
17719 } else {
17720 PyErr_Clear(); // clear the failure of the wxPyConvert above
17721 arg2 = wxPyCBInputStream_create(obj1, false);
17722 if (arg2 == NULL) {
17723 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17724 SWIG_fail;
17725 }
17726 created2 = true;
17727 }
17728 }
17729 if (obj2) {
17730 ecode3 = SWIG_AsVal_long(obj2, &val3);
17731 if (!SWIG_IsOK(ecode3)) {
17732 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
17733 }
17734 arg3 = static_cast< long >(val3);
17735 }
17736 if (obj3) {
17737 ecode4 = SWIG_AsVal_int(obj3, &val4);
17738 if (!SWIG_IsOK(ecode4)) {
17739 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
17740 }
17741 arg4 = static_cast< int >(val4);
17742 }
17743 {
17744 PyThreadState* __tstate = wxPyBeginAllowThreads();
17745 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
17746 wxPyEndAllowThreads(__tstate);
17747 if (PyErr_Occurred()) SWIG_fail;
17748 }
17749 {
17750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17751 }
17752 {
17753 if (created2) delete arg2;
17754 }
17755 return resultobj;
17756 fail:
17757 {
17758 if (created2) delete arg2;
17759 }
17760 return NULL;
17761 }
17762
17763
17764 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17765 PyObject *resultobj = 0;
17766 wxImage *arg1 = (wxImage *) 0 ;
17767 wxInputStream *arg2 = 0 ;
17768 wxString *arg3 = 0 ;
17769 int arg4 = (int) -1 ;
17770 bool result;
17771 void *argp1 = 0 ;
17772 int res1 = 0 ;
17773 wxPyInputStream *temp2 ;
17774 bool created2 ;
17775 bool temp3 = false ;
17776 int val4 ;
17777 int ecode4 = 0 ;
17778 PyObject * obj0 = 0 ;
17779 PyObject * obj1 = 0 ;
17780 PyObject * obj2 = 0 ;
17781 PyObject * obj3 = 0 ;
17782 char * kwnames[] = {
17783 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
17784 };
17785
17786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17788 if (!SWIG_IsOK(res1)) {
17789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
17790 }
17791 arg1 = reinterpret_cast< wxImage * >(argp1);
17792 {
17793 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17794 arg2 = temp2->m_wxis;
17795 created2 = false;
17796 } else {
17797 PyErr_Clear(); // clear the failure of the wxPyConvert above
17798 arg2 = wxPyCBInputStream_create(obj1, false);
17799 if (arg2 == NULL) {
17800 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17801 SWIG_fail;
17802 }
17803 created2 = true;
17804 }
17805 }
17806 {
17807 arg3 = wxString_in_helper(obj2);
17808 if (arg3 == NULL) SWIG_fail;
17809 temp3 = true;
17810 }
17811 if (obj3) {
17812 ecode4 = SWIG_AsVal_int(obj3, &val4);
17813 if (!SWIG_IsOK(ecode4)) {
17814 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
17815 }
17816 arg4 = static_cast< int >(val4);
17817 }
17818 {
17819 PyThreadState* __tstate = wxPyBeginAllowThreads();
17820 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
17821 wxPyEndAllowThreads(__tstate);
17822 if (PyErr_Occurred()) SWIG_fail;
17823 }
17824 {
17825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17826 }
17827 {
17828 if (created2) delete arg2;
17829 }
17830 {
17831 if (temp3)
17832 delete arg3;
17833 }
17834 return resultobj;
17835 fail:
17836 {
17837 if (created2) delete arg2;
17838 }
17839 {
17840 if (temp3)
17841 delete arg3;
17842 }
17843 return NULL;
17844 }
17845
17846
17847 SWIGINTERN PyObject *_wrap_Image_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17848 PyObject *resultobj = 0;
17849 wxImage *arg1 = (wxImage *) 0 ;
17850 bool result;
17851 void *argp1 = 0 ;
17852 int res1 = 0 ;
17853 PyObject *swig_obj[1] ;
17854
17855 if (!args) SWIG_fail;
17856 swig_obj[0] = args;
17857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17858 if (!SWIG_IsOK(res1)) {
17859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsOk" "', expected argument " "1"" of type '" "wxImage *""'");
17860 }
17861 arg1 = reinterpret_cast< wxImage * >(argp1);
17862 {
17863 PyThreadState* __tstate = wxPyBeginAllowThreads();
17864 result = (bool)(arg1)->IsOk();
17865 wxPyEndAllowThreads(__tstate);
17866 if (PyErr_Occurred()) SWIG_fail;
17867 }
17868 {
17869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17870 }
17871 return resultobj;
17872 fail:
17873 return NULL;
17874 }
17875
17876
17877 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17878 PyObject *resultobj = 0;
17879 wxImage *arg1 = (wxImage *) 0 ;
17880 int result;
17881 void *argp1 = 0 ;
17882 int res1 = 0 ;
17883 PyObject *swig_obj[1] ;
17884
17885 if (!args) SWIG_fail;
17886 swig_obj[0] = args;
17887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17888 if (!SWIG_IsOK(res1)) {
17889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
17890 }
17891 arg1 = reinterpret_cast< wxImage * >(argp1);
17892 {
17893 PyThreadState* __tstate = wxPyBeginAllowThreads();
17894 result = (int)(arg1)->GetWidth();
17895 wxPyEndAllowThreads(__tstate);
17896 if (PyErr_Occurred()) SWIG_fail;
17897 }
17898 resultobj = SWIG_From_int(static_cast< int >(result));
17899 return resultobj;
17900 fail:
17901 return NULL;
17902 }
17903
17904
17905 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17906 PyObject *resultobj = 0;
17907 wxImage *arg1 = (wxImage *) 0 ;
17908 int result;
17909 void *argp1 = 0 ;
17910 int res1 = 0 ;
17911 PyObject *swig_obj[1] ;
17912
17913 if (!args) SWIG_fail;
17914 swig_obj[0] = args;
17915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17916 if (!SWIG_IsOK(res1)) {
17917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
17918 }
17919 arg1 = reinterpret_cast< wxImage * >(argp1);
17920 {
17921 PyThreadState* __tstate = wxPyBeginAllowThreads();
17922 result = (int)(arg1)->GetHeight();
17923 wxPyEndAllowThreads(__tstate);
17924 if (PyErr_Occurred()) SWIG_fail;
17925 }
17926 resultobj = SWIG_From_int(static_cast< int >(result));
17927 return resultobj;
17928 fail:
17929 return NULL;
17930 }
17931
17932
17933 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17934 PyObject *resultobj = 0;
17935 wxImage *arg1 = (wxImage *) 0 ;
17936 wxSize result;
17937 void *argp1 = 0 ;
17938 int res1 = 0 ;
17939 PyObject *swig_obj[1] ;
17940
17941 if (!args) SWIG_fail;
17942 swig_obj[0] = args;
17943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17944 if (!SWIG_IsOK(res1)) {
17945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
17946 }
17947 arg1 = reinterpret_cast< wxImage * >(argp1);
17948 {
17949 PyThreadState* __tstate = wxPyBeginAllowThreads();
17950 result = wxImage_GetSize(arg1);
17951 wxPyEndAllowThreads(__tstate);
17952 if (PyErr_Occurred()) SWIG_fail;
17953 }
17954 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
17955 return resultobj;
17956 fail:
17957 return NULL;
17958 }
17959
17960
17961 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17962 PyObject *resultobj = 0;
17963 wxImage *arg1 = (wxImage *) 0 ;
17964 wxRect *arg2 = 0 ;
17965 SwigValueWrapper<wxImage > result;
17966 void *argp1 = 0 ;
17967 int res1 = 0 ;
17968 wxRect temp2 ;
17969 PyObject * obj0 = 0 ;
17970 PyObject * obj1 = 0 ;
17971 char * kwnames[] = {
17972 (char *) "self",(char *) "rect", NULL
17973 };
17974
17975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
17976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17977 if (!SWIG_IsOK(res1)) {
17978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
17979 }
17980 arg1 = reinterpret_cast< wxImage * >(argp1);
17981 {
17982 arg2 = &temp2;
17983 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
17984 }
17985 {
17986 PyThreadState* __tstate = wxPyBeginAllowThreads();
17987 result = (arg1)->GetSubImage((wxRect const &)*arg2);
17988 wxPyEndAllowThreads(__tstate);
17989 if (PyErr_Occurred()) SWIG_fail;
17990 }
17991 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
17992 return resultobj;
17993 fail:
17994 return NULL;
17995 }
17996
17997
17998 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17999 PyObject *resultobj = 0;
18000 wxImage *arg1 = (wxImage *) 0 ;
18001 wxSize *arg2 = 0 ;
18002 wxPoint *arg3 = 0 ;
18003 int arg4 = (int) -1 ;
18004 int arg5 = (int) -1 ;
18005 int arg6 = (int) -1 ;
18006 SwigValueWrapper<wxImage > result;
18007 void *argp1 = 0 ;
18008 int res1 = 0 ;
18009 wxSize temp2 ;
18010 wxPoint temp3 ;
18011 int val4 ;
18012 int ecode4 = 0 ;
18013 int val5 ;
18014 int ecode5 = 0 ;
18015 int val6 ;
18016 int ecode6 = 0 ;
18017 PyObject * obj0 = 0 ;
18018 PyObject * obj1 = 0 ;
18019 PyObject * obj2 = 0 ;
18020 PyObject * obj3 = 0 ;
18021 PyObject * obj4 = 0 ;
18022 PyObject * obj5 = 0 ;
18023 char * kwnames[] = {
18024 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
18025 };
18026
18027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
18028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18029 if (!SWIG_IsOK(res1)) {
18030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
18031 }
18032 arg1 = reinterpret_cast< wxImage * >(argp1);
18033 {
18034 arg2 = &temp2;
18035 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
18036 }
18037 {
18038 arg3 = &temp3;
18039 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18040 }
18041 if (obj3) {
18042 ecode4 = SWIG_AsVal_int(obj3, &val4);
18043 if (!SWIG_IsOK(ecode4)) {
18044 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
18045 }
18046 arg4 = static_cast< int >(val4);
18047 }
18048 if (obj4) {
18049 ecode5 = SWIG_AsVal_int(obj4, &val5);
18050 if (!SWIG_IsOK(ecode5)) {
18051 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
18052 }
18053 arg5 = static_cast< int >(val5);
18054 }
18055 if (obj5) {
18056 ecode6 = SWIG_AsVal_int(obj5, &val6);
18057 if (!SWIG_IsOK(ecode6)) {
18058 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
18059 }
18060 arg6 = static_cast< int >(val6);
18061 }
18062 {
18063 PyThreadState* __tstate = wxPyBeginAllowThreads();
18064 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
18065 wxPyEndAllowThreads(__tstate);
18066 if (PyErr_Occurred()) SWIG_fail;
18067 }
18068 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18069 return resultobj;
18070 fail:
18071 return NULL;
18072 }
18073
18074
18075 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18076 PyObject *resultobj = 0;
18077 wxImage *arg1 = (wxImage *) 0 ;
18078 SwigValueWrapper<wxImage > result;
18079 void *argp1 = 0 ;
18080 int res1 = 0 ;
18081 PyObject *swig_obj[1] ;
18082
18083 if (!args) SWIG_fail;
18084 swig_obj[0] = args;
18085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18086 if (!SWIG_IsOK(res1)) {
18087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
18088 }
18089 arg1 = reinterpret_cast< wxImage * >(argp1);
18090 {
18091 PyThreadState* __tstate = wxPyBeginAllowThreads();
18092 result = (arg1)->Copy();
18093 wxPyEndAllowThreads(__tstate);
18094 if (PyErr_Occurred()) SWIG_fail;
18095 }
18096 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18097 return resultobj;
18098 fail:
18099 return NULL;
18100 }
18101
18102
18103 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18104 PyObject *resultobj = 0;
18105 wxImage *arg1 = (wxImage *) 0 ;
18106 wxImage *arg2 = 0 ;
18107 int arg3 ;
18108 int arg4 ;
18109 void *argp1 = 0 ;
18110 int res1 = 0 ;
18111 void *argp2 = 0 ;
18112 int res2 = 0 ;
18113 int val3 ;
18114 int ecode3 = 0 ;
18115 int val4 ;
18116 int ecode4 = 0 ;
18117 PyObject * obj0 = 0 ;
18118 PyObject * obj1 = 0 ;
18119 PyObject * obj2 = 0 ;
18120 PyObject * obj3 = 0 ;
18121 char * kwnames[] = {
18122 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
18123 };
18124
18125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18127 if (!SWIG_IsOK(res1)) {
18128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
18129 }
18130 arg1 = reinterpret_cast< wxImage * >(argp1);
18131 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
18132 if (!SWIG_IsOK(res2)) {
18133 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18134 }
18135 if (!argp2) {
18136 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18137 }
18138 arg2 = reinterpret_cast< wxImage * >(argp2);
18139 ecode3 = SWIG_AsVal_int(obj2, &val3);
18140 if (!SWIG_IsOK(ecode3)) {
18141 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
18142 }
18143 arg3 = static_cast< int >(val3);
18144 ecode4 = SWIG_AsVal_int(obj3, &val4);
18145 if (!SWIG_IsOK(ecode4)) {
18146 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
18147 }
18148 arg4 = static_cast< int >(val4);
18149 {
18150 PyThreadState* __tstate = wxPyBeginAllowThreads();
18151 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
18152 wxPyEndAllowThreads(__tstate);
18153 if (PyErr_Occurred()) SWIG_fail;
18154 }
18155 resultobj = SWIG_Py_Void();
18156 return resultobj;
18157 fail:
18158 return NULL;
18159 }
18160
18161
18162 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18163 PyObject *resultobj = 0;
18164 wxImage *arg1 = (wxImage *) 0 ;
18165 PyObject *result = 0 ;
18166 void *argp1 = 0 ;
18167 int res1 = 0 ;
18168 PyObject *swig_obj[1] ;
18169
18170 if (!args) SWIG_fail;
18171 swig_obj[0] = args;
18172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18173 if (!SWIG_IsOK(res1)) {
18174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
18175 }
18176 arg1 = reinterpret_cast< wxImage * >(argp1);
18177 {
18178 PyThreadState* __tstate = wxPyBeginAllowThreads();
18179 result = (PyObject *)wxImage_GetData(arg1);
18180 wxPyEndAllowThreads(__tstate);
18181 if (PyErr_Occurred()) SWIG_fail;
18182 }
18183 resultobj = result;
18184 return resultobj;
18185 fail:
18186 return NULL;
18187 }
18188
18189
18190 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18191 PyObject *resultobj = 0;
18192 wxImage *arg1 = (wxImage *) 0 ;
18193 buffer arg2 ;
18194 int arg3 ;
18195 void *argp1 = 0 ;
18196 int res1 = 0 ;
18197 Py_ssize_t temp2 ;
18198 PyObject * obj0 = 0 ;
18199 PyObject * obj1 = 0 ;
18200 char * kwnames[] = {
18201 (char *) "self",(char *) "data", NULL
18202 };
18203
18204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
18205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18206 if (!SWIG_IsOK(res1)) {
18207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
18208 }
18209 arg1 = reinterpret_cast< wxImage * >(argp1);
18210 {
18211 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18212 arg3 = (int)temp2;
18213 }
18214 {
18215 PyThreadState* __tstate = wxPyBeginAllowThreads();
18216 wxImage_SetData(arg1,arg2,arg3);
18217 wxPyEndAllowThreads(__tstate);
18218 if (PyErr_Occurred()) SWIG_fail;
18219 }
18220 resultobj = SWIG_Py_Void();
18221 return resultobj;
18222 fail:
18223 return NULL;
18224 }
18225
18226
18227 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18228 PyObject *resultobj = 0;
18229 wxImage *arg1 = (wxImage *) 0 ;
18230 PyObject *result = 0 ;
18231 void *argp1 = 0 ;
18232 int res1 = 0 ;
18233 PyObject *swig_obj[1] ;
18234
18235 if (!args) SWIG_fail;
18236 swig_obj[0] = args;
18237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18238 if (!SWIG_IsOK(res1)) {
18239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18240 }
18241 arg1 = reinterpret_cast< wxImage * >(argp1);
18242 {
18243 PyThreadState* __tstate = wxPyBeginAllowThreads();
18244 result = (PyObject *)wxImage_GetDataBuffer(arg1);
18245 wxPyEndAllowThreads(__tstate);
18246 if (PyErr_Occurred()) SWIG_fail;
18247 }
18248 resultobj = result;
18249 return resultobj;
18250 fail:
18251 return NULL;
18252 }
18253
18254
18255 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18256 PyObject *resultobj = 0;
18257 wxImage *arg1 = (wxImage *) 0 ;
18258 buffer arg2 ;
18259 int arg3 ;
18260 void *argp1 = 0 ;
18261 int res1 = 0 ;
18262 Py_ssize_t temp2 ;
18263 PyObject * obj0 = 0 ;
18264 PyObject * obj1 = 0 ;
18265 char * kwnames[] = {
18266 (char *) "self",(char *) "data", NULL
18267 };
18268
18269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18271 if (!SWIG_IsOK(res1)) {
18272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18273 }
18274 arg1 = reinterpret_cast< wxImage * >(argp1);
18275 {
18276 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18277 arg3 = (int)temp2;
18278 }
18279 {
18280 PyThreadState* __tstate = wxPyBeginAllowThreads();
18281 wxImage_SetDataBuffer(arg1,arg2,arg3);
18282 wxPyEndAllowThreads(__tstate);
18283 if (PyErr_Occurred()) SWIG_fail;
18284 }
18285 resultobj = SWIG_Py_Void();
18286 return resultobj;
18287 fail:
18288 return NULL;
18289 }
18290
18291
18292 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18293 PyObject *resultobj = 0;
18294 wxImage *arg1 = (wxImage *) 0 ;
18295 PyObject *result = 0 ;
18296 void *argp1 = 0 ;
18297 int res1 = 0 ;
18298 PyObject *swig_obj[1] ;
18299
18300 if (!args) SWIG_fail;
18301 swig_obj[0] = args;
18302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18303 if (!SWIG_IsOK(res1)) {
18304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18305 }
18306 arg1 = reinterpret_cast< wxImage * >(argp1);
18307 {
18308 PyThreadState* __tstate = wxPyBeginAllowThreads();
18309 result = (PyObject *)wxImage_GetAlphaData(arg1);
18310 wxPyEndAllowThreads(__tstate);
18311 if (PyErr_Occurred()) SWIG_fail;
18312 }
18313 resultobj = result;
18314 return resultobj;
18315 fail:
18316 return NULL;
18317 }
18318
18319
18320 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18321 PyObject *resultobj = 0;
18322 wxImage *arg1 = (wxImage *) 0 ;
18323 buffer arg2 ;
18324 int arg3 ;
18325 void *argp1 = 0 ;
18326 int res1 = 0 ;
18327 Py_ssize_t temp2 ;
18328 PyObject * obj0 = 0 ;
18329 PyObject * obj1 = 0 ;
18330 char * kwnames[] = {
18331 (char *) "self",(char *) "alpha", NULL
18332 };
18333
18334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
18335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18336 if (!SWIG_IsOK(res1)) {
18337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18338 }
18339 arg1 = reinterpret_cast< wxImage * >(argp1);
18340 {
18341 if (obj1 != Py_None) {
18342 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18343 arg3 = (int)temp2;
18344 }
18345 }
18346 {
18347 PyThreadState* __tstate = wxPyBeginAllowThreads();
18348 wxImage_SetAlphaData(arg1,arg2,arg3);
18349 wxPyEndAllowThreads(__tstate);
18350 if (PyErr_Occurred()) SWIG_fail;
18351 }
18352 resultobj = SWIG_Py_Void();
18353 return resultobj;
18354 fail:
18355 return NULL;
18356 }
18357
18358
18359 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18360 PyObject *resultobj = 0;
18361 wxImage *arg1 = (wxImage *) 0 ;
18362 PyObject *result = 0 ;
18363 void *argp1 = 0 ;
18364 int res1 = 0 ;
18365 PyObject *swig_obj[1] ;
18366
18367 if (!args) SWIG_fail;
18368 swig_obj[0] = args;
18369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18370 if (!SWIG_IsOK(res1)) {
18371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18372 }
18373 arg1 = reinterpret_cast< wxImage * >(argp1);
18374 {
18375 PyThreadState* __tstate = wxPyBeginAllowThreads();
18376 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
18377 wxPyEndAllowThreads(__tstate);
18378 if (PyErr_Occurred()) SWIG_fail;
18379 }
18380 resultobj = result;
18381 return resultobj;
18382 fail:
18383 return NULL;
18384 }
18385
18386
18387 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18388 PyObject *resultobj = 0;
18389 wxImage *arg1 = (wxImage *) 0 ;
18390 buffer arg2 ;
18391 int arg3 ;
18392 void *argp1 = 0 ;
18393 int res1 = 0 ;
18394 Py_ssize_t temp2 ;
18395 PyObject * obj0 = 0 ;
18396 PyObject * obj1 = 0 ;
18397 char * kwnames[] = {
18398 (char *) "self",(char *) "alpha", NULL
18399 };
18400
18401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18403 if (!SWIG_IsOK(res1)) {
18404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18405 }
18406 arg1 = reinterpret_cast< wxImage * >(argp1);
18407 {
18408 if (obj1 != Py_None) {
18409 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18410 arg3 = (int)temp2;
18411 }
18412 }
18413 {
18414 PyThreadState* __tstate = wxPyBeginAllowThreads();
18415 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
18416 wxPyEndAllowThreads(__tstate);
18417 if (PyErr_Occurred()) SWIG_fail;
18418 }
18419 resultobj = SWIG_Py_Void();
18420 return resultobj;
18421 fail:
18422 return NULL;
18423 }
18424
18425
18426 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18427 PyObject *resultobj = 0;
18428 wxImage *arg1 = (wxImage *) 0 ;
18429 byte arg2 ;
18430 byte arg3 ;
18431 byte arg4 ;
18432 void *argp1 = 0 ;
18433 int res1 = 0 ;
18434 unsigned char val2 ;
18435 int ecode2 = 0 ;
18436 unsigned char val3 ;
18437 int ecode3 = 0 ;
18438 unsigned char val4 ;
18439 int ecode4 = 0 ;
18440 PyObject * obj0 = 0 ;
18441 PyObject * obj1 = 0 ;
18442 PyObject * obj2 = 0 ;
18443 PyObject * obj3 = 0 ;
18444 char * kwnames[] = {
18445 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
18446 };
18447
18448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18450 if (!SWIG_IsOK(res1)) {
18451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
18452 }
18453 arg1 = reinterpret_cast< wxImage * >(argp1);
18454 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18455 if (!SWIG_IsOK(ecode2)) {
18456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
18457 }
18458 arg2 = static_cast< byte >(val2);
18459 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18460 if (!SWIG_IsOK(ecode3)) {
18461 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
18462 }
18463 arg3 = static_cast< byte >(val3);
18464 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18465 if (!SWIG_IsOK(ecode4)) {
18466 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
18467 }
18468 arg4 = static_cast< byte >(val4);
18469 {
18470 PyThreadState* __tstate = wxPyBeginAllowThreads();
18471 (arg1)->SetMaskColour(arg2,arg3,arg4);
18472 wxPyEndAllowThreads(__tstate);
18473 if (PyErr_Occurred()) SWIG_fail;
18474 }
18475 resultobj = SWIG_Py_Void();
18476 return resultobj;
18477 fail:
18478 return NULL;
18479 }
18480
18481
18482 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18483 PyObject *resultobj = 0;
18484 wxImage *arg1 = (wxImage *) 0 ;
18485 byte *arg2 = (byte *) 0 ;
18486 byte *arg3 = (byte *) 0 ;
18487 byte *arg4 = (byte *) 0 ;
18488 void *argp1 = 0 ;
18489 int res1 = 0 ;
18490 byte temp2 ;
18491 int res2 = SWIG_TMPOBJ ;
18492 byte temp3 ;
18493 int res3 = SWIG_TMPOBJ ;
18494 byte temp4 ;
18495 int res4 = SWIG_TMPOBJ ;
18496 PyObject *swig_obj[1] ;
18497
18498 arg2 = &temp2;
18499 arg3 = &temp3;
18500 arg4 = &temp4;
18501 if (!args) SWIG_fail;
18502 swig_obj[0] = args;
18503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18504 if (!SWIG_IsOK(res1)) {
18505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
18506 }
18507 arg1 = reinterpret_cast< wxImage * >(argp1);
18508 {
18509 PyThreadState* __tstate = wxPyBeginAllowThreads();
18510 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
18511 wxPyEndAllowThreads(__tstate);
18512 if (PyErr_Occurred()) SWIG_fail;
18513 }
18514 resultobj = SWIG_Py_Void();
18515 if (SWIG_IsTmpObj(res2)) {
18516 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
18517 } else {
18518 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18519 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
18520 }
18521 if (SWIG_IsTmpObj(res3)) {
18522 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
18523 } else {
18524 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18525 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
18526 }
18527 if (SWIG_IsTmpObj(res4)) {
18528 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
18529 } else {
18530 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18531 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
18532 }
18533 return resultobj;
18534 fail:
18535 return NULL;
18536 }
18537
18538
18539 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18540 PyObject *resultobj = 0;
18541 wxImage *arg1 = (wxImage *) 0 ;
18542 byte result;
18543 void *argp1 = 0 ;
18544 int res1 = 0 ;
18545 PyObject *swig_obj[1] ;
18546
18547 if (!args) SWIG_fail;
18548 swig_obj[0] = args;
18549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18550 if (!SWIG_IsOK(res1)) {
18551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
18552 }
18553 arg1 = reinterpret_cast< wxImage * >(argp1);
18554 {
18555 PyThreadState* __tstate = wxPyBeginAllowThreads();
18556 result = (byte)(arg1)->GetMaskRed();
18557 wxPyEndAllowThreads(__tstate);
18558 if (PyErr_Occurred()) SWIG_fail;
18559 }
18560 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18561 return resultobj;
18562 fail:
18563 return NULL;
18564 }
18565
18566
18567 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18568 PyObject *resultobj = 0;
18569 wxImage *arg1 = (wxImage *) 0 ;
18570 byte result;
18571 void *argp1 = 0 ;
18572 int res1 = 0 ;
18573 PyObject *swig_obj[1] ;
18574
18575 if (!args) SWIG_fail;
18576 swig_obj[0] = args;
18577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18578 if (!SWIG_IsOK(res1)) {
18579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
18580 }
18581 arg1 = reinterpret_cast< wxImage * >(argp1);
18582 {
18583 PyThreadState* __tstate = wxPyBeginAllowThreads();
18584 result = (byte)(arg1)->GetMaskGreen();
18585 wxPyEndAllowThreads(__tstate);
18586 if (PyErr_Occurred()) SWIG_fail;
18587 }
18588 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18589 return resultobj;
18590 fail:
18591 return NULL;
18592 }
18593
18594
18595 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18596 PyObject *resultobj = 0;
18597 wxImage *arg1 = (wxImage *) 0 ;
18598 byte result;
18599 void *argp1 = 0 ;
18600 int res1 = 0 ;
18601 PyObject *swig_obj[1] ;
18602
18603 if (!args) SWIG_fail;
18604 swig_obj[0] = args;
18605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18606 if (!SWIG_IsOK(res1)) {
18607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
18608 }
18609 arg1 = reinterpret_cast< wxImage * >(argp1);
18610 {
18611 PyThreadState* __tstate = wxPyBeginAllowThreads();
18612 result = (byte)(arg1)->GetMaskBlue();
18613 wxPyEndAllowThreads(__tstate);
18614 if (PyErr_Occurred()) SWIG_fail;
18615 }
18616 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18617 return resultobj;
18618 fail:
18619 return NULL;
18620 }
18621
18622
18623 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18624 PyObject *resultobj = 0;
18625 wxImage *arg1 = (wxImage *) 0 ;
18626 bool arg2 = (bool) true ;
18627 void *argp1 = 0 ;
18628 int res1 = 0 ;
18629 bool val2 ;
18630 int ecode2 = 0 ;
18631 PyObject * obj0 = 0 ;
18632 PyObject * obj1 = 0 ;
18633 char * kwnames[] = {
18634 (char *) "self",(char *) "mask", NULL
18635 };
18636
18637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
18638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18639 if (!SWIG_IsOK(res1)) {
18640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
18641 }
18642 arg1 = reinterpret_cast< wxImage * >(argp1);
18643 if (obj1) {
18644 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18645 if (!SWIG_IsOK(ecode2)) {
18646 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
18647 }
18648 arg2 = static_cast< bool >(val2);
18649 }
18650 {
18651 PyThreadState* __tstate = wxPyBeginAllowThreads();
18652 (arg1)->SetMask(arg2);
18653 wxPyEndAllowThreads(__tstate);
18654 if (PyErr_Occurred()) SWIG_fail;
18655 }
18656 resultobj = SWIG_Py_Void();
18657 return resultobj;
18658 fail:
18659 return NULL;
18660 }
18661
18662
18663 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18664 PyObject *resultobj = 0;
18665 wxImage *arg1 = (wxImage *) 0 ;
18666 bool result;
18667 void *argp1 = 0 ;
18668 int res1 = 0 ;
18669 PyObject *swig_obj[1] ;
18670
18671 if (!args) SWIG_fail;
18672 swig_obj[0] = args;
18673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18674 if (!SWIG_IsOK(res1)) {
18675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
18676 }
18677 arg1 = reinterpret_cast< wxImage * >(argp1);
18678 {
18679 PyThreadState* __tstate = wxPyBeginAllowThreads();
18680 result = (bool)(arg1)->HasMask();
18681 wxPyEndAllowThreads(__tstate);
18682 if (PyErr_Occurred()) SWIG_fail;
18683 }
18684 {
18685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18686 }
18687 return resultobj;
18688 fail:
18689 return NULL;
18690 }
18691
18692
18693 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18694 PyObject *resultobj = 0;
18695 wxImage *arg1 = (wxImage *) 0 ;
18696 double arg2 ;
18697 wxPoint *arg3 = 0 ;
18698 bool arg4 = (bool) true ;
18699 wxPoint *arg5 = (wxPoint *) NULL ;
18700 SwigValueWrapper<wxImage > result;
18701 void *argp1 = 0 ;
18702 int res1 = 0 ;
18703 double val2 ;
18704 int ecode2 = 0 ;
18705 wxPoint temp3 ;
18706 bool val4 ;
18707 int ecode4 = 0 ;
18708 void *argp5 = 0 ;
18709 int res5 = 0 ;
18710 PyObject * obj0 = 0 ;
18711 PyObject * obj1 = 0 ;
18712 PyObject * obj2 = 0 ;
18713 PyObject * obj3 = 0 ;
18714 PyObject * obj4 = 0 ;
18715 char * kwnames[] = {
18716 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
18717 };
18718
18719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18721 if (!SWIG_IsOK(res1)) {
18722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
18723 }
18724 arg1 = reinterpret_cast< wxImage * >(argp1);
18725 ecode2 = SWIG_AsVal_double(obj1, &val2);
18726 if (!SWIG_IsOK(ecode2)) {
18727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
18728 }
18729 arg2 = static_cast< double >(val2);
18730 {
18731 arg3 = &temp3;
18732 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18733 }
18734 if (obj3) {
18735 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18736 if (!SWIG_IsOK(ecode4)) {
18737 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
18738 }
18739 arg4 = static_cast< bool >(val4);
18740 }
18741 if (obj4) {
18742 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
18743 if (!SWIG_IsOK(res5)) {
18744 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
18745 }
18746 arg5 = reinterpret_cast< wxPoint * >(argp5);
18747 }
18748 {
18749 PyThreadState* __tstate = wxPyBeginAllowThreads();
18750 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
18751 wxPyEndAllowThreads(__tstate);
18752 if (PyErr_Occurred()) SWIG_fail;
18753 }
18754 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18755 return resultobj;
18756 fail:
18757 return NULL;
18758 }
18759
18760
18761 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18762 PyObject *resultobj = 0;
18763 wxImage *arg1 = (wxImage *) 0 ;
18764 bool arg2 = (bool) true ;
18765 SwigValueWrapper<wxImage > result;
18766 void *argp1 = 0 ;
18767 int res1 = 0 ;
18768 bool val2 ;
18769 int ecode2 = 0 ;
18770 PyObject * obj0 = 0 ;
18771 PyObject * obj1 = 0 ;
18772 char * kwnames[] = {
18773 (char *) "self",(char *) "clockwise", NULL
18774 };
18775
18776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
18777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18778 if (!SWIG_IsOK(res1)) {
18779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
18780 }
18781 arg1 = reinterpret_cast< wxImage * >(argp1);
18782 if (obj1) {
18783 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18784 if (!SWIG_IsOK(ecode2)) {
18785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
18786 }
18787 arg2 = static_cast< bool >(val2);
18788 }
18789 {
18790 PyThreadState* __tstate = wxPyBeginAllowThreads();
18791 result = (arg1)->Rotate90(arg2);
18792 wxPyEndAllowThreads(__tstate);
18793 if (PyErr_Occurred()) SWIG_fail;
18794 }
18795 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18796 return resultobj;
18797 fail:
18798 return NULL;
18799 }
18800
18801
18802 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18803 PyObject *resultobj = 0;
18804 wxImage *arg1 = (wxImage *) 0 ;
18805 bool arg2 = (bool) true ;
18806 SwigValueWrapper<wxImage > result;
18807 void *argp1 = 0 ;
18808 int res1 = 0 ;
18809 bool val2 ;
18810 int ecode2 = 0 ;
18811 PyObject * obj0 = 0 ;
18812 PyObject * obj1 = 0 ;
18813 char * kwnames[] = {
18814 (char *) "self",(char *) "horizontally", NULL
18815 };
18816
18817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
18818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18819 if (!SWIG_IsOK(res1)) {
18820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
18821 }
18822 arg1 = reinterpret_cast< wxImage * >(argp1);
18823 if (obj1) {
18824 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18825 if (!SWIG_IsOK(ecode2)) {
18826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
18827 }
18828 arg2 = static_cast< bool >(val2);
18829 }
18830 {
18831 PyThreadState* __tstate = wxPyBeginAllowThreads();
18832 result = (arg1)->Mirror(arg2);
18833 wxPyEndAllowThreads(__tstate);
18834 if (PyErr_Occurred()) SWIG_fail;
18835 }
18836 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18837 return resultobj;
18838 fail:
18839 return NULL;
18840 }
18841
18842
18843 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18844 PyObject *resultobj = 0;
18845 wxImage *arg1 = (wxImage *) 0 ;
18846 byte arg2 ;
18847 byte arg3 ;
18848 byte arg4 ;
18849 byte arg5 ;
18850 byte arg6 ;
18851 byte arg7 ;
18852 void *argp1 = 0 ;
18853 int res1 = 0 ;
18854 unsigned char val2 ;
18855 int ecode2 = 0 ;
18856 unsigned char val3 ;
18857 int ecode3 = 0 ;
18858 unsigned char val4 ;
18859 int ecode4 = 0 ;
18860 unsigned char val5 ;
18861 int ecode5 = 0 ;
18862 unsigned char val6 ;
18863 int ecode6 = 0 ;
18864 unsigned char val7 ;
18865 int ecode7 = 0 ;
18866 PyObject * obj0 = 0 ;
18867 PyObject * obj1 = 0 ;
18868 PyObject * obj2 = 0 ;
18869 PyObject * obj3 = 0 ;
18870 PyObject * obj4 = 0 ;
18871 PyObject * obj5 = 0 ;
18872 PyObject * obj6 = 0 ;
18873 char * kwnames[] = {
18874 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
18875 };
18876
18877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
18878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18879 if (!SWIG_IsOK(res1)) {
18880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
18881 }
18882 arg1 = reinterpret_cast< wxImage * >(argp1);
18883 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18884 if (!SWIG_IsOK(ecode2)) {
18885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
18886 }
18887 arg2 = static_cast< byte >(val2);
18888 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18889 if (!SWIG_IsOK(ecode3)) {
18890 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
18891 }
18892 arg3 = static_cast< byte >(val3);
18893 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18894 if (!SWIG_IsOK(ecode4)) {
18895 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
18896 }
18897 arg4 = static_cast< byte >(val4);
18898 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
18899 if (!SWIG_IsOK(ecode5)) {
18900 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
18901 }
18902 arg5 = static_cast< byte >(val5);
18903 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
18904 if (!SWIG_IsOK(ecode6)) {
18905 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
18906 }
18907 arg6 = static_cast< byte >(val6);
18908 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
18909 if (!SWIG_IsOK(ecode7)) {
18910 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
18911 }
18912 arg7 = static_cast< byte >(val7);
18913 {
18914 PyThreadState* __tstate = wxPyBeginAllowThreads();
18915 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
18916 wxPyEndAllowThreads(__tstate);
18917 if (PyErr_Occurred()) SWIG_fail;
18918 }
18919 resultobj = SWIG_Py_Void();
18920 return resultobj;
18921 fail:
18922 return NULL;
18923 }
18924
18925
18926 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18927 PyObject *resultobj = 0;
18928 wxImage *arg1 = (wxImage *) 0 ;
18929 double arg2 = (double) 0.299 ;
18930 double arg3 = (double) 0.587 ;
18931 double arg4 = (double) 0.114 ;
18932 SwigValueWrapper<wxImage > result;
18933 void *argp1 = 0 ;
18934 int res1 = 0 ;
18935 double val2 ;
18936 int ecode2 = 0 ;
18937 double val3 ;
18938 int ecode3 = 0 ;
18939 double val4 ;
18940 int ecode4 = 0 ;
18941 PyObject * obj0 = 0 ;
18942 PyObject * obj1 = 0 ;
18943 PyObject * obj2 = 0 ;
18944 PyObject * obj3 = 0 ;
18945 char * kwnames[] = {
18946 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
18947 };
18948
18949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18951 if (!SWIG_IsOK(res1)) {
18952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
18953 }
18954 arg1 = reinterpret_cast< wxImage * >(argp1);
18955 if (obj1) {
18956 ecode2 = SWIG_AsVal_double(obj1, &val2);
18957 if (!SWIG_IsOK(ecode2)) {
18958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
18959 }
18960 arg2 = static_cast< double >(val2);
18961 }
18962 if (obj2) {
18963 ecode3 = SWIG_AsVal_double(obj2, &val3);
18964 if (!SWIG_IsOK(ecode3)) {
18965 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
18966 }
18967 arg3 = static_cast< double >(val3);
18968 }
18969 if (obj3) {
18970 ecode4 = SWIG_AsVal_double(obj3, &val4);
18971 if (!SWIG_IsOK(ecode4)) {
18972 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
18973 }
18974 arg4 = static_cast< double >(val4);
18975 }
18976 {
18977 PyThreadState* __tstate = wxPyBeginAllowThreads();
18978 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
18979 wxPyEndAllowThreads(__tstate);
18980 if (PyErr_Occurred()) SWIG_fail;
18981 }
18982 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18983 return resultobj;
18984 fail:
18985 return NULL;
18986 }
18987
18988
18989 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18990 PyObject *resultobj = 0;
18991 wxImage *arg1 = (wxImage *) 0 ;
18992 byte arg2 ;
18993 byte arg3 ;
18994 byte arg4 ;
18995 SwigValueWrapper<wxImage > result;
18996 void *argp1 = 0 ;
18997 int res1 = 0 ;
18998 unsigned char val2 ;
18999 int ecode2 = 0 ;
19000 unsigned char val3 ;
19001 int ecode3 = 0 ;
19002 unsigned char val4 ;
19003 int ecode4 = 0 ;
19004 PyObject * obj0 = 0 ;
19005 PyObject * obj1 = 0 ;
19006 PyObject * obj2 = 0 ;
19007 PyObject * obj3 = 0 ;
19008 char * kwnames[] = {
19009 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
19010 };
19011
19012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19014 if (!SWIG_IsOK(res1)) {
19015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
19016 }
19017 arg1 = reinterpret_cast< wxImage * >(argp1);
19018 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19019 if (!SWIG_IsOK(ecode2)) {
19020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
19021 }
19022 arg2 = static_cast< byte >(val2);
19023 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19024 if (!SWIG_IsOK(ecode3)) {
19025 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
19026 }
19027 arg3 = static_cast< byte >(val3);
19028 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19029 if (!SWIG_IsOK(ecode4)) {
19030 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
19031 }
19032 arg4 = static_cast< byte >(val4);
19033 {
19034 PyThreadState* __tstate = wxPyBeginAllowThreads();
19035 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
19036 wxPyEndAllowThreads(__tstate);
19037 if (PyErr_Occurred()) SWIG_fail;
19038 }
19039 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19040 return resultobj;
19041 fail:
19042 return NULL;
19043 }
19044
19045
19046 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19047 PyObject *resultobj = 0;
19048 wxImage *arg1 = (wxImage *) 0 ;
19049 wxString *arg2 = 0 ;
19050 wxString *arg3 = 0 ;
19051 void *argp1 = 0 ;
19052 int res1 = 0 ;
19053 bool temp2 = false ;
19054 bool temp3 = false ;
19055 PyObject * obj0 = 0 ;
19056 PyObject * obj1 = 0 ;
19057 PyObject * obj2 = 0 ;
19058 char * kwnames[] = {
19059 (char *) "self",(char *) "name",(char *) "value", NULL
19060 };
19061
19062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19064 if (!SWIG_IsOK(res1)) {
19065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
19066 }
19067 arg1 = reinterpret_cast< wxImage * >(argp1);
19068 {
19069 arg2 = wxString_in_helper(obj1);
19070 if (arg2 == NULL) SWIG_fail;
19071 temp2 = true;
19072 }
19073 {
19074 arg3 = wxString_in_helper(obj2);
19075 if (arg3 == NULL) SWIG_fail;
19076 temp3 = true;
19077 }
19078 {
19079 PyThreadState* __tstate = wxPyBeginAllowThreads();
19080 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
19081 wxPyEndAllowThreads(__tstate);
19082 if (PyErr_Occurred()) SWIG_fail;
19083 }
19084 resultobj = SWIG_Py_Void();
19085 {
19086 if (temp2)
19087 delete arg2;
19088 }
19089 {
19090 if (temp3)
19091 delete arg3;
19092 }
19093 return resultobj;
19094 fail:
19095 {
19096 if (temp2)
19097 delete arg2;
19098 }
19099 {
19100 if (temp3)
19101 delete arg3;
19102 }
19103 return NULL;
19104 }
19105
19106
19107 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19108 PyObject *resultobj = 0;
19109 wxImage *arg1 = (wxImage *) 0 ;
19110 wxString *arg2 = 0 ;
19111 int arg3 ;
19112 void *argp1 = 0 ;
19113 int res1 = 0 ;
19114 bool temp2 = false ;
19115 int val3 ;
19116 int ecode3 = 0 ;
19117 PyObject * obj0 = 0 ;
19118 PyObject * obj1 = 0 ;
19119 PyObject * obj2 = 0 ;
19120 char * kwnames[] = {
19121 (char *) "self",(char *) "name",(char *) "value", NULL
19122 };
19123
19124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19126 if (!SWIG_IsOK(res1)) {
19127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
19128 }
19129 arg1 = reinterpret_cast< wxImage * >(argp1);
19130 {
19131 arg2 = wxString_in_helper(obj1);
19132 if (arg2 == NULL) SWIG_fail;
19133 temp2 = true;
19134 }
19135 ecode3 = SWIG_AsVal_int(obj2, &val3);
19136 if (!SWIG_IsOK(ecode3)) {
19137 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
19138 }
19139 arg3 = static_cast< int >(val3);
19140 {
19141 PyThreadState* __tstate = wxPyBeginAllowThreads();
19142 (arg1)->SetOption((wxString const &)*arg2,arg3);
19143 wxPyEndAllowThreads(__tstate);
19144 if (PyErr_Occurred()) SWIG_fail;
19145 }
19146 resultobj = SWIG_Py_Void();
19147 {
19148 if (temp2)
19149 delete arg2;
19150 }
19151 return resultobj;
19152 fail:
19153 {
19154 if (temp2)
19155 delete arg2;
19156 }
19157 return NULL;
19158 }
19159
19160
19161 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19162 PyObject *resultobj = 0;
19163 wxImage *arg1 = (wxImage *) 0 ;
19164 wxString *arg2 = 0 ;
19165 wxString result;
19166 void *argp1 = 0 ;
19167 int res1 = 0 ;
19168 bool temp2 = false ;
19169 PyObject * obj0 = 0 ;
19170 PyObject * obj1 = 0 ;
19171 char * kwnames[] = {
19172 (char *) "self",(char *) "name", NULL
19173 };
19174
19175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
19176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19177 if (!SWIG_IsOK(res1)) {
19178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19179 }
19180 arg1 = reinterpret_cast< wxImage * >(argp1);
19181 {
19182 arg2 = wxString_in_helper(obj1);
19183 if (arg2 == NULL) SWIG_fail;
19184 temp2 = true;
19185 }
19186 {
19187 PyThreadState* __tstate = wxPyBeginAllowThreads();
19188 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
19189 wxPyEndAllowThreads(__tstate);
19190 if (PyErr_Occurred()) SWIG_fail;
19191 }
19192 {
19193 #if wxUSE_UNICODE
19194 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19195 #else
19196 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19197 #endif
19198 }
19199 {
19200 if (temp2)
19201 delete arg2;
19202 }
19203 return resultobj;
19204 fail:
19205 {
19206 if (temp2)
19207 delete arg2;
19208 }
19209 return NULL;
19210 }
19211
19212
19213 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19214 PyObject *resultobj = 0;
19215 wxImage *arg1 = (wxImage *) 0 ;
19216 wxString *arg2 = 0 ;
19217 int result;
19218 void *argp1 = 0 ;
19219 int res1 = 0 ;
19220 bool temp2 = false ;
19221 PyObject * obj0 = 0 ;
19222 PyObject * obj1 = 0 ;
19223 char * kwnames[] = {
19224 (char *) "self",(char *) "name", NULL
19225 };
19226
19227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
19228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19229 if (!SWIG_IsOK(res1)) {
19230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
19231 }
19232 arg1 = reinterpret_cast< wxImage * >(argp1);
19233 {
19234 arg2 = wxString_in_helper(obj1);
19235 if (arg2 == NULL) SWIG_fail;
19236 temp2 = true;
19237 }
19238 {
19239 PyThreadState* __tstate = wxPyBeginAllowThreads();
19240 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
19241 wxPyEndAllowThreads(__tstate);
19242 if (PyErr_Occurred()) SWIG_fail;
19243 }
19244 resultobj = SWIG_From_int(static_cast< int >(result));
19245 {
19246 if (temp2)
19247 delete arg2;
19248 }
19249 return resultobj;
19250 fail:
19251 {
19252 if (temp2)
19253 delete arg2;
19254 }
19255 return NULL;
19256 }
19257
19258
19259 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19260 PyObject *resultobj = 0;
19261 wxImage *arg1 = (wxImage *) 0 ;
19262 wxString *arg2 = 0 ;
19263 bool result;
19264 void *argp1 = 0 ;
19265 int res1 = 0 ;
19266 bool temp2 = false ;
19267 PyObject * obj0 = 0 ;
19268 PyObject * obj1 = 0 ;
19269 char * kwnames[] = {
19270 (char *) "self",(char *) "name", NULL
19271 };
19272
19273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
19274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19275 if (!SWIG_IsOK(res1)) {
19276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19277 }
19278 arg1 = reinterpret_cast< wxImage * >(argp1);
19279 {
19280 arg2 = wxString_in_helper(obj1);
19281 if (arg2 == NULL) SWIG_fail;
19282 temp2 = true;
19283 }
19284 {
19285 PyThreadState* __tstate = wxPyBeginAllowThreads();
19286 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
19287 wxPyEndAllowThreads(__tstate);
19288 if (PyErr_Occurred()) SWIG_fail;
19289 }
19290 {
19291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19292 }
19293 {
19294 if (temp2)
19295 delete arg2;
19296 }
19297 return resultobj;
19298 fail:
19299 {
19300 if (temp2)
19301 delete arg2;
19302 }
19303 return NULL;
19304 }
19305
19306
19307 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19308 PyObject *resultobj = 0;
19309 wxImage *arg1 = (wxImage *) 0 ;
19310 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
19311 unsigned long result;
19312 void *argp1 = 0 ;
19313 int res1 = 0 ;
19314 unsigned long val2 ;
19315 int ecode2 = 0 ;
19316 PyObject * obj0 = 0 ;
19317 PyObject * obj1 = 0 ;
19318 char * kwnames[] = {
19319 (char *) "self",(char *) "stopafter", NULL
19320 };
19321
19322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
19323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19324 if (!SWIG_IsOK(res1)) {
19325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
19326 }
19327 arg1 = reinterpret_cast< wxImage * >(argp1);
19328 if (obj1) {
19329 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
19330 if (!SWIG_IsOK(ecode2)) {
19331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
19332 }
19333 arg2 = static_cast< unsigned long >(val2);
19334 }
19335 {
19336 PyThreadState* __tstate = wxPyBeginAllowThreads();
19337 result = (unsigned long)(arg1)->CountColours(arg2);
19338 wxPyEndAllowThreads(__tstate);
19339 if (PyErr_Occurred()) SWIG_fail;
19340 }
19341 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19342 return resultobj;
19343 fail:
19344 return NULL;
19345 }
19346
19347
19348 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19349 PyObject *resultobj = 0;
19350 wxImage *arg1 = (wxImage *) 0 ;
19351 wxImageHistogram *arg2 = 0 ;
19352 unsigned long result;
19353 void *argp1 = 0 ;
19354 int res1 = 0 ;
19355 void *argp2 = 0 ;
19356 int res2 = 0 ;
19357 PyObject * obj0 = 0 ;
19358 PyObject * obj1 = 0 ;
19359 char * kwnames[] = {
19360 (char *) "self",(char *) "h", NULL
19361 };
19362
19363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
19364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19365 if (!SWIG_IsOK(res1)) {
19366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
19367 }
19368 arg1 = reinterpret_cast< wxImage * >(argp1);
19369 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
19370 if (!SWIG_IsOK(res2)) {
19371 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19372 }
19373 if (!argp2) {
19374 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19375 }
19376 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
19377 {
19378 PyThreadState* __tstate = wxPyBeginAllowThreads();
19379 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
19380 wxPyEndAllowThreads(__tstate);
19381 if (PyErr_Occurred()) SWIG_fail;
19382 }
19383 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19384 return resultobj;
19385 fail:
19386 return NULL;
19387 }
19388
19389
19390 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19391 PyObject *resultobj = 0;
19392 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19393 void *argp1 = 0 ;
19394 int res1 = 0 ;
19395 PyObject * obj0 = 0 ;
19396 char * kwnames[] = {
19397 (char *) "handler", NULL
19398 };
19399
19400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
19401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19402 if (!SWIG_IsOK(res1)) {
19403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19404 }
19405 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19406 {
19407 PyThreadState* __tstate = wxPyBeginAllowThreads();
19408 wxImage::AddHandler(arg1);
19409 wxPyEndAllowThreads(__tstate);
19410 if (PyErr_Occurred()) SWIG_fail;
19411 }
19412 resultobj = SWIG_Py_Void();
19413 return resultobj;
19414 fail:
19415 return NULL;
19416 }
19417
19418
19419 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19420 PyObject *resultobj = 0;
19421 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19422 void *argp1 = 0 ;
19423 int res1 = 0 ;
19424 PyObject * obj0 = 0 ;
19425 char * kwnames[] = {
19426 (char *) "handler", NULL
19427 };
19428
19429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
19430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19431 if (!SWIG_IsOK(res1)) {
19432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19433 }
19434 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19435 {
19436 PyThreadState* __tstate = wxPyBeginAllowThreads();
19437 wxImage::InsertHandler(arg1);
19438 wxPyEndAllowThreads(__tstate);
19439 if (PyErr_Occurred()) SWIG_fail;
19440 }
19441 resultobj = SWIG_Py_Void();
19442 return resultobj;
19443 fail:
19444 return NULL;
19445 }
19446
19447
19448 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19449 PyObject *resultobj = 0;
19450 wxString *arg1 = 0 ;
19451 bool result;
19452 bool temp1 = false ;
19453 PyObject * obj0 = 0 ;
19454 char * kwnames[] = {
19455 (char *) "name", NULL
19456 };
19457
19458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
19459 {
19460 arg1 = wxString_in_helper(obj0);
19461 if (arg1 == NULL) SWIG_fail;
19462 temp1 = true;
19463 }
19464 {
19465 PyThreadState* __tstate = wxPyBeginAllowThreads();
19466 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
19467 wxPyEndAllowThreads(__tstate);
19468 if (PyErr_Occurred()) SWIG_fail;
19469 }
19470 {
19471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19472 }
19473 {
19474 if (temp1)
19475 delete arg1;
19476 }
19477 return resultobj;
19478 fail:
19479 {
19480 if (temp1)
19481 delete arg1;
19482 }
19483 return NULL;
19484 }
19485
19486
19487 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19488 PyObject *resultobj = 0;
19489 PyObject *result = 0 ;
19490
19491 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
19492 {
19493 PyThreadState* __tstate = wxPyBeginAllowThreads();
19494 result = (PyObject *)wxImage_GetHandlers();
19495 wxPyEndAllowThreads(__tstate);
19496 if (PyErr_Occurred()) SWIG_fail;
19497 }
19498 resultobj = result;
19499 return resultobj;
19500 fail:
19501 return NULL;
19502 }
19503
19504
19505 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19506 PyObject *resultobj = 0;
19507 wxString result;
19508
19509 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
19510 {
19511 PyThreadState* __tstate = wxPyBeginAllowThreads();
19512 result = wxImage::GetImageExtWildcard();
19513 wxPyEndAllowThreads(__tstate);
19514 if (PyErr_Occurred()) SWIG_fail;
19515 }
19516 {
19517 #if wxUSE_UNICODE
19518 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19519 #else
19520 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19521 #endif
19522 }
19523 return resultobj;
19524 fail:
19525 return NULL;
19526 }
19527
19528
19529 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19530 PyObject *resultobj = 0;
19531 wxImage *arg1 = (wxImage *) 0 ;
19532 int arg2 = (int) -1 ;
19533 wxBitmap result;
19534 void *argp1 = 0 ;
19535 int res1 = 0 ;
19536 int val2 ;
19537 int ecode2 = 0 ;
19538 PyObject * obj0 = 0 ;
19539 PyObject * obj1 = 0 ;
19540 char * kwnames[] = {
19541 (char *) "self",(char *) "depth", NULL
19542 };
19543
19544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
19545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19546 if (!SWIG_IsOK(res1)) {
19547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19548 }
19549 arg1 = reinterpret_cast< wxImage * >(argp1);
19550 if (obj1) {
19551 ecode2 = SWIG_AsVal_int(obj1, &val2);
19552 if (!SWIG_IsOK(ecode2)) {
19553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
19554 }
19555 arg2 = static_cast< int >(val2);
19556 }
19557 {
19558 if (!wxPyCheckForApp()) SWIG_fail;
19559 PyThreadState* __tstate = wxPyBeginAllowThreads();
19560 result = wxImage_ConvertToBitmap(arg1,arg2);
19561 wxPyEndAllowThreads(__tstate);
19562 if (PyErr_Occurred()) SWIG_fail;
19563 }
19564 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19565 return resultobj;
19566 fail:
19567 return NULL;
19568 }
19569
19570
19571 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19572 PyObject *resultobj = 0;
19573 wxImage *arg1 = (wxImage *) 0 ;
19574 byte arg2 ;
19575 byte arg3 ;
19576 byte arg4 ;
19577 wxBitmap result;
19578 void *argp1 = 0 ;
19579 int res1 = 0 ;
19580 unsigned char val2 ;
19581 int ecode2 = 0 ;
19582 unsigned char val3 ;
19583 int ecode3 = 0 ;
19584 unsigned char val4 ;
19585 int ecode4 = 0 ;
19586 PyObject * obj0 = 0 ;
19587 PyObject * obj1 = 0 ;
19588 PyObject * obj2 = 0 ;
19589 PyObject * obj3 = 0 ;
19590 char * kwnames[] = {
19591 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
19592 };
19593
19594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19596 if (!SWIG_IsOK(res1)) {
19597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19598 }
19599 arg1 = reinterpret_cast< wxImage * >(argp1);
19600 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19601 if (!SWIG_IsOK(ecode2)) {
19602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
19603 }
19604 arg2 = static_cast< byte >(val2);
19605 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19606 if (!SWIG_IsOK(ecode3)) {
19607 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
19608 }
19609 arg3 = static_cast< byte >(val3);
19610 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19611 if (!SWIG_IsOK(ecode4)) {
19612 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
19613 }
19614 arg4 = static_cast< byte >(val4);
19615 {
19616 if (!wxPyCheckForApp()) SWIG_fail;
19617 PyThreadState* __tstate = wxPyBeginAllowThreads();
19618 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
19619 wxPyEndAllowThreads(__tstate);
19620 if (PyErr_Occurred()) SWIG_fail;
19621 }
19622 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19623 return resultobj;
19624 fail:
19625 return NULL;
19626 }
19627
19628
19629 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19630 PyObject *resultobj = 0;
19631 wxImage *arg1 = (wxImage *) 0 ;
19632 double arg2 ;
19633 void *argp1 = 0 ;
19634 int res1 = 0 ;
19635 double val2 ;
19636 int ecode2 = 0 ;
19637 PyObject * obj0 = 0 ;
19638 PyObject * obj1 = 0 ;
19639 char * kwnames[] = {
19640 (char *) "self",(char *) "angle", NULL
19641 };
19642
19643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
19644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19645 if (!SWIG_IsOK(res1)) {
19646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
19647 }
19648 arg1 = reinterpret_cast< wxImage * >(argp1);
19649 ecode2 = SWIG_AsVal_double(obj1, &val2);
19650 if (!SWIG_IsOK(ecode2)) {
19651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
19652 }
19653 arg2 = static_cast< double >(val2);
19654 {
19655 PyThreadState* __tstate = wxPyBeginAllowThreads();
19656 (arg1)->RotateHue(arg2);
19657 wxPyEndAllowThreads(__tstate);
19658 if (PyErr_Occurred()) SWIG_fail;
19659 }
19660 resultobj = SWIG_Py_Void();
19661 return resultobj;
19662 fail:
19663 return NULL;
19664 }
19665
19666
19667 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19668 PyObject *resultobj = 0;
19669 wxImage_RGBValue arg1 ;
19670 wxImage_HSVValue result;
19671 void *argp1 ;
19672 int res1 = 0 ;
19673 PyObject * obj0 = 0 ;
19674 char * kwnames[] = {
19675 (char *) "rgb", NULL
19676 };
19677
19678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
19679 {
19680 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
19681 if (!SWIG_IsOK(res1)) {
19682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19683 }
19684 if (!argp1) {
19685 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19686 } else {
19687 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
19688 arg1 = *temp;
19689 if (SWIG_IsNewObj(res1)) delete temp;
19690 }
19691 }
19692 {
19693 PyThreadState* __tstate = wxPyBeginAllowThreads();
19694 result = wxImage::RGBtoHSV(arg1);
19695 wxPyEndAllowThreads(__tstate);
19696 if (PyErr_Occurred()) SWIG_fail;
19697 }
19698 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
19699 return resultobj;
19700 fail:
19701 return NULL;
19702 }
19703
19704
19705 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19706 PyObject *resultobj = 0;
19707 wxImage_HSVValue arg1 ;
19708 wxImage_RGBValue result;
19709 void *argp1 ;
19710 int res1 = 0 ;
19711 PyObject * obj0 = 0 ;
19712 char * kwnames[] = {
19713 (char *) "hsv", NULL
19714 };
19715
19716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
19717 {
19718 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
19719 if (!SWIG_IsOK(res1)) {
19720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19721 }
19722 if (!argp1) {
19723 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19724 } else {
19725 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
19726 arg1 = *temp;
19727 if (SWIG_IsNewObj(res1)) delete temp;
19728 }
19729 }
19730 {
19731 PyThreadState* __tstate = wxPyBeginAllowThreads();
19732 result = wxImage::HSVtoRGB(arg1);
19733 wxPyEndAllowThreads(__tstate);
19734 if (PyErr_Occurred()) SWIG_fail;
19735 }
19736 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
19737 return resultobj;
19738 fail:
19739 return NULL;
19740 }
19741
19742
19743 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19744 PyObject *obj;
19745 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19746 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
19747 return SWIG_Py_Void();
19748 }
19749
19750 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19751 return SWIG_Python_InitShadowInstance(args);
19752 }
19753
19754 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19755 PyObject *resultobj = 0;
19756 int arg1 ;
19757 int arg2 ;
19758 buffer arg3 ;
19759 int arg4 ;
19760 buffer arg5 = (buffer) NULL ;
19761 int arg6 = (int) 0 ;
19762 wxImage *result = 0 ;
19763 int val1 ;
19764 int ecode1 = 0 ;
19765 int val2 ;
19766 int ecode2 = 0 ;
19767 Py_ssize_t temp3 ;
19768 Py_ssize_t temp5 ;
19769 PyObject * obj0 = 0 ;
19770 PyObject * obj1 = 0 ;
19771 PyObject * obj2 = 0 ;
19772 PyObject * obj3 = 0 ;
19773 char * kwnames[] = {
19774 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
19775 };
19776
19777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19778 ecode1 = SWIG_AsVal_int(obj0, &val1);
19779 if (!SWIG_IsOK(ecode1)) {
19780 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
19781 }
19782 arg1 = static_cast< int >(val1);
19783 ecode2 = SWIG_AsVal_int(obj1, &val2);
19784 if (!SWIG_IsOK(ecode2)) {
19785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
19786 }
19787 arg2 = static_cast< int >(val2);
19788 {
19789 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
19790 arg4 = (int)temp3;
19791 }
19792 if (obj3) {
19793 {
19794 if (obj3 != Py_None) {
19795 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
19796 arg6 = (int)temp5;
19797 }
19798 }
19799 }
19800 {
19801 PyThreadState* __tstate = wxPyBeginAllowThreads();
19802 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
19803 wxPyEndAllowThreads(__tstate);
19804 if (PyErr_Occurred()) SWIG_fail;
19805 }
19806 {
19807 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
19808 }
19809 return resultobj;
19810 fail:
19811 return NULL;
19812 }
19813
19814
19815 SWIGINTERN int NullImage_set(PyObject *) {
19816 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
19817 return 1;
19818 }
19819
19820
19821 SWIGINTERN PyObject *NullImage_get(void) {
19822 PyObject *pyobj = 0;
19823
19824 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
19825 return pyobj;
19826 }
19827
19828
19829 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
19830 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
19831 return 1;
19832 }
19833
19834
19835 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
19836 PyObject *pyobj = 0;
19837
19838 {
19839 #if wxUSE_UNICODE
19840 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19841 #else
19842 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19843 #endif
19844 }
19845 return pyobj;
19846 }
19847
19848
19849 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
19850 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
19851 return 1;
19852 }
19853
19854
19855 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
19856 PyObject *pyobj = 0;
19857
19858 {
19859 #if wxUSE_UNICODE
19860 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19861 #else
19862 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19863 #endif
19864 }
19865 return pyobj;
19866 }
19867
19868
19869 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
19870 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
19871 return 1;
19872 }
19873
19874
19875 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
19876 PyObject *pyobj = 0;
19877
19878 {
19879 #if wxUSE_UNICODE
19880 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19881 #else
19882 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19883 #endif
19884 }
19885 return pyobj;
19886 }
19887
19888
19889 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
19890 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
19891 return 1;
19892 }
19893
19894
19895 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
19896 PyObject *pyobj = 0;
19897
19898 {
19899 #if wxUSE_UNICODE
19900 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19901 #else
19902 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19903 #endif
19904 }
19905 return pyobj;
19906 }
19907
19908
19909 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
19910 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
19911 return 1;
19912 }
19913
19914
19915 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
19916 PyObject *pyobj = 0;
19917
19918 {
19919 #if wxUSE_UNICODE
19920 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19921 #else
19922 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19923 #endif
19924 }
19925 return pyobj;
19926 }
19927
19928
19929 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
19930 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
19931 return 1;
19932 }
19933
19934
19935 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
19936 PyObject *pyobj = 0;
19937
19938 {
19939 #if wxUSE_UNICODE
19940 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
19941 #else
19942 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
19943 #endif
19944 }
19945 return pyobj;
19946 }
19947
19948
19949 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
19950 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
19951 return 1;
19952 }
19953
19954
19955 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
19956 PyObject *pyobj = 0;
19957
19958 {
19959 #if wxUSE_UNICODE
19960 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
19961 #else
19962 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
19963 #endif
19964 }
19965 return pyobj;
19966 }
19967
19968
19969 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
19970 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
19971 return 1;
19972 }
19973
19974
19975 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
19976 PyObject *pyobj = 0;
19977
19978 {
19979 #if wxUSE_UNICODE
19980 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
19981 #else
19982 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
19983 #endif
19984 }
19985 return pyobj;
19986 }
19987
19988
19989 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
19990 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
19991 return 1;
19992 }
19993
19994
19995 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
19996 PyObject *pyobj = 0;
19997
19998 {
19999 #if wxUSE_UNICODE
20000 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
20001 #else
20002 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
20003 #endif
20004 }
20005 return pyobj;
20006 }
20007
20008
20009 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
20010 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
20011 return 1;
20012 }
20013
20014
20015 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
20016 PyObject *pyobj = 0;
20017
20018 {
20019 #if wxUSE_UNICODE
20020 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20021 #else
20022 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20023 #endif
20024 }
20025 return pyobj;
20026 }
20027
20028
20029 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
20030 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
20031 return 1;
20032 }
20033
20034
20035 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
20036 PyObject *pyobj = 0;
20037
20038 {
20039 #if wxUSE_UNICODE
20040 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20041 #else
20042 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20043 #endif
20044 }
20045 return pyobj;
20046 }
20047
20048
20049 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
20050 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
20051 return 1;
20052 }
20053
20054
20055 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
20056 PyObject *pyobj = 0;
20057
20058 {
20059 #if wxUSE_UNICODE
20060 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20061 #else
20062 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20063 #endif
20064 }
20065 return pyobj;
20066 }
20067
20068
20069 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
20070 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
20071 return 1;
20072 }
20073
20074
20075 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
20076 PyObject *pyobj = 0;
20077
20078 {
20079 #if wxUSE_UNICODE
20080 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20081 #else
20082 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20083 #endif
20084 }
20085 return pyobj;
20086 }
20087
20088
20089 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
20090 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
20091 return 1;
20092 }
20093
20094
20095 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
20096 PyObject *pyobj = 0;
20097
20098 {
20099 #if wxUSE_UNICODE
20100 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20101 #else
20102 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20103 #endif
20104 }
20105 return pyobj;
20106 }
20107
20108
20109 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
20110 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
20111 return 1;
20112 }
20113
20114
20115 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
20116 PyObject *pyobj = 0;
20117
20118 {
20119 #if wxUSE_UNICODE
20120 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20121 #else
20122 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20123 #endif
20124 }
20125 return pyobj;
20126 }
20127
20128
20129 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20130 PyObject *resultobj = 0;
20131 wxBMPHandler *result = 0 ;
20132
20133 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
20134 {
20135 PyThreadState* __tstate = wxPyBeginAllowThreads();
20136 result = (wxBMPHandler *)new wxBMPHandler();
20137 wxPyEndAllowThreads(__tstate);
20138 if (PyErr_Occurred()) SWIG_fail;
20139 }
20140 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
20141 return resultobj;
20142 fail:
20143 return NULL;
20144 }
20145
20146
20147 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20148 PyObject *obj;
20149 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20150 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
20151 return SWIG_Py_Void();
20152 }
20153
20154 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20155 return SWIG_Python_InitShadowInstance(args);
20156 }
20157
20158 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20159 PyObject *resultobj = 0;
20160 wxICOHandler *result = 0 ;
20161
20162 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
20163 {
20164 PyThreadState* __tstate = wxPyBeginAllowThreads();
20165 result = (wxICOHandler *)new wxICOHandler();
20166 wxPyEndAllowThreads(__tstate);
20167 if (PyErr_Occurred()) SWIG_fail;
20168 }
20169 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
20170 return resultobj;
20171 fail:
20172 return NULL;
20173 }
20174
20175
20176 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20177 PyObject *obj;
20178 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20179 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
20180 return SWIG_Py_Void();
20181 }
20182
20183 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20184 return SWIG_Python_InitShadowInstance(args);
20185 }
20186
20187 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20188 PyObject *resultobj = 0;
20189 wxCURHandler *result = 0 ;
20190
20191 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
20192 {
20193 PyThreadState* __tstate = wxPyBeginAllowThreads();
20194 result = (wxCURHandler *)new wxCURHandler();
20195 wxPyEndAllowThreads(__tstate);
20196 if (PyErr_Occurred()) SWIG_fail;
20197 }
20198 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
20199 return resultobj;
20200 fail:
20201 return NULL;
20202 }
20203
20204
20205 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20206 PyObject *obj;
20207 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20208 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
20209 return SWIG_Py_Void();
20210 }
20211
20212 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20213 return SWIG_Python_InitShadowInstance(args);
20214 }
20215
20216 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20217 PyObject *resultobj = 0;
20218 wxANIHandler *result = 0 ;
20219
20220 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
20221 {
20222 PyThreadState* __tstate = wxPyBeginAllowThreads();
20223 result = (wxANIHandler *)new wxANIHandler();
20224 wxPyEndAllowThreads(__tstate);
20225 if (PyErr_Occurred()) SWIG_fail;
20226 }
20227 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
20228 return resultobj;
20229 fail:
20230 return NULL;
20231 }
20232
20233
20234 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20235 PyObject *obj;
20236 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20237 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
20238 return SWIG_Py_Void();
20239 }
20240
20241 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20242 return SWIG_Python_InitShadowInstance(args);
20243 }
20244
20245 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20246 PyObject *resultobj = 0;
20247 wxPNGHandler *result = 0 ;
20248
20249 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
20250 {
20251 PyThreadState* __tstate = wxPyBeginAllowThreads();
20252 result = (wxPNGHandler *)new wxPNGHandler();
20253 wxPyEndAllowThreads(__tstate);
20254 if (PyErr_Occurred()) SWIG_fail;
20255 }
20256 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
20257 return resultobj;
20258 fail:
20259 return NULL;
20260 }
20261
20262
20263 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20264 PyObject *obj;
20265 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20266 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
20267 return SWIG_Py_Void();
20268 }
20269
20270 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20271 return SWIG_Python_InitShadowInstance(args);
20272 }
20273
20274 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20275 PyObject *resultobj = 0;
20276 wxGIFHandler *result = 0 ;
20277
20278 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
20279 {
20280 PyThreadState* __tstate = wxPyBeginAllowThreads();
20281 result = (wxGIFHandler *)new wxGIFHandler();
20282 wxPyEndAllowThreads(__tstate);
20283 if (PyErr_Occurred()) SWIG_fail;
20284 }
20285 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
20286 return resultobj;
20287 fail:
20288 return NULL;
20289 }
20290
20291
20292 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20293 PyObject *obj;
20294 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20295 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
20296 return SWIG_Py_Void();
20297 }
20298
20299 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20300 return SWIG_Python_InitShadowInstance(args);
20301 }
20302
20303 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20304 PyObject *resultobj = 0;
20305 wxPCXHandler *result = 0 ;
20306
20307 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
20308 {
20309 PyThreadState* __tstate = wxPyBeginAllowThreads();
20310 result = (wxPCXHandler *)new wxPCXHandler();
20311 wxPyEndAllowThreads(__tstate);
20312 if (PyErr_Occurred()) SWIG_fail;
20313 }
20314 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
20315 return resultobj;
20316 fail:
20317 return NULL;
20318 }
20319
20320
20321 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20322 PyObject *obj;
20323 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20324 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
20325 return SWIG_Py_Void();
20326 }
20327
20328 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20329 return SWIG_Python_InitShadowInstance(args);
20330 }
20331
20332 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20333 PyObject *resultobj = 0;
20334 wxJPEGHandler *result = 0 ;
20335
20336 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
20337 {
20338 PyThreadState* __tstate = wxPyBeginAllowThreads();
20339 result = (wxJPEGHandler *)new wxJPEGHandler();
20340 wxPyEndAllowThreads(__tstate);
20341 if (PyErr_Occurred()) SWIG_fail;
20342 }
20343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
20344 return resultobj;
20345 fail:
20346 return NULL;
20347 }
20348
20349
20350 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20351 PyObject *obj;
20352 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20353 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
20354 return SWIG_Py_Void();
20355 }
20356
20357 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20358 return SWIG_Python_InitShadowInstance(args);
20359 }
20360
20361 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20362 PyObject *resultobj = 0;
20363 wxPNMHandler *result = 0 ;
20364
20365 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
20366 {
20367 PyThreadState* __tstate = wxPyBeginAllowThreads();
20368 result = (wxPNMHandler *)new wxPNMHandler();
20369 wxPyEndAllowThreads(__tstate);
20370 if (PyErr_Occurred()) SWIG_fail;
20371 }
20372 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
20373 return resultobj;
20374 fail:
20375 return NULL;
20376 }
20377
20378
20379 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20380 PyObject *obj;
20381 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20382 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
20383 return SWIG_Py_Void();
20384 }
20385
20386 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20387 return SWIG_Python_InitShadowInstance(args);
20388 }
20389
20390 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20391 PyObject *resultobj = 0;
20392 wxXPMHandler *result = 0 ;
20393
20394 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
20395 {
20396 PyThreadState* __tstate = wxPyBeginAllowThreads();
20397 result = (wxXPMHandler *)new wxXPMHandler();
20398 wxPyEndAllowThreads(__tstate);
20399 if (PyErr_Occurred()) SWIG_fail;
20400 }
20401 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
20402 return resultobj;
20403 fail:
20404 return NULL;
20405 }
20406
20407
20408 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20409 PyObject *obj;
20410 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20411 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
20412 return SWIG_Py_Void();
20413 }
20414
20415 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20416 return SWIG_Python_InitShadowInstance(args);
20417 }
20418
20419 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20420 PyObject *resultobj = 0;
20421 wxTIFFHandler *result = 0 ;
20422
20423 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
20424 {
20425 PyThreadState* __tstate = wxPyBeginAllowThreads();
20426 result = (wxTIFFHandler *)new wxTIFFHandler();
20427 wxPyEndAllowThreads(__tstate);
20428 if (PyErr_Occurred()) SWIG_fail;
20429 }
20430 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
20431 return resultobj;
20432 fail:
20433 return NULL;
20434 }
20435
20436
20437 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20438 PyObject *obj;
20439 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20440 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
20441 return SWIG_Py_Void();
20442 }
20443
20444 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20445 return SWIG_Python_InitShadowInstance(args);
20446 }
20447
20448 SWIGINTERN PyObject *_wrap_new_TGAHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20449 PyObject *resultobj = 0;
20450 wxTGAHandler *result = 0 ;
20451
20452 if (!SWIG_Python_UnpackTuple(args,"new_TGAHandler",0,0,0)) SWIG_fail;
20453 {
20454 PyThreadState* __tstate = wxPyBeginAllowThreads();
20455 result = (wxTGAHandler *)new wxTGAHandler();
20456 wxPyEndAllowThreads(__tstate);
20457 if (PyErr_Occurred()) SWIG_fail;
20458 }
20459 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTGAHandler, SWIG_POINTER_NEW | 0 );
20460 return resultobj;
20461 fail:
20462 return NULL;
20463 }
20464
20465
20466 SWIGINTERN PyObject *TGAHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20467 PyObject *obj;
20468 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20469 SWIG_TypeNewClientData(SWIGTYPE_p_wxTGAHandler, SWIG_NewClientData(obj));
20470 return SWIG_Py_Void();
20471 }
20472
20473 SWIGINTERN PyObject *TGAHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20474 return SWIG_Python_InitShadowInstance(args);
20475 }
20476
20477 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20478 PyObject *resultobj = 0;
20479 wxImage *arg1 = 0 ;
20480 wxImage *arg2 = 0 ;
20481 int arg3 = (int) 236 ;
20482 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
20483 bool result;
20484 void *argp1 = 0 ;
20485 int res1 = 0 ;
20486 void *argp2 = 0 ;
20487 int res2 = 0 ;
20488 int val3 ;
20489 int ecode3 = 0 ;
20490 int val4 ;
20491 int ecode4 = 0 ;
20492 PyObject * obj0 = 0 ;
20493 PyObject * obj1 = 0 ;
20494 PyObject * obj2 = 0 ;
20495 PyObject * obj3 = 0 ;
20496 char * kwnames[] = {
20497 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
20498 };
20499
20500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20501 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
20502 if (!SWIG_IsOK(res1)) {
20503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20504 }
20505 if (!argp1) {
20506 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20507 }
20508 arg1 = reinterpret_cast< wxImage * >(argp1);
20509 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
20510 if (!SWIG_IsOK(res2)) {
20511 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20512 }
20513 if (!argp2) {
20514 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20515 }
20516 arg2 = reinterpret_cast< wxImage * >(argp2);
20517 if (obj2) {
20518 ecode3 = SWIG_AsVal_int(obj2, &val3);
20519 if (!SWIG_IsOK(ecode3)) {
20520 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
20521 }
20522 arg3 = static_cast< int >(val3);
20523 }
20524 if (obj3) {
20525 ecode4 = SWIG_AsVal_int(obj3, &val4);
20526 if (!SWIG_IsOK(ecode4)) {
20527 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
20528 }
20529 arg4 = static_cast< int >(val4);
20530 }
20531 {
20532 PyThreadState* __tstate = wxPyBeginAllowThreads();
20533 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
20534 wxPyEndAllowThreads(__tstate);
20535 if (PyErr_Occurred()) SWIG_fail;
20536 }
20537 {
20538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20539 }
20540 return resultobj;
20541 fail:
20542 return NULL;
20543 }
20544
20545
20546 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20547 PyObject *obj;
20548 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20549 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
20550 return SWIG_Py_Void();
20551 }
20552
20553 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20554 PyObject *resultobj = 0;
20555 wxEvtHandler *result = 0 ;
20556
20557 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
20558 {
20559 PyThreadState* __tstate = wxPyBeginAllowThreads();
20560 result = (wxEvtHandler *)new wxEvtHandler();
20561 wxPyEndAllowThreads(__tstate);
20562 if (PyErr_Occurred()) SWIG_fail;
20563 }
20564 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
20565 return resultobj;
20566 fail:
20567 return NULL;
20568 }
20569
20570
20571 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20572 PyObject *resultobj = 0;
20573 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20574 wxEvtHandler *result = 0 ;
20575 void *argp1 = 0 ;
20576 int res1 = 0 ;
20577 PyObject *swig_obj[1] ;
20578
20579 if (!args) SWIG_fail;
20580 swig_obj[0] = args;
20581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20582 if (!SWIG_IsOK(res1)) {
20583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20584 }
20585 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20586 {
20587 PyThreadState* __tstate = wxPyBeginAllowThreads();
20588 result = (wxEvtHandler *)(arg1)->GetNextHandler();
20589 wxPyEndAllowThreads(__tstate);
20590 if (PyErr_Occurred()) SWIG_fail;
20591 }
20592 {
20593 resultobj = wxPyMake_wxObject(result, 0);
20594 }
20595 return resultobj;
20596 fail:
20597 return NULL;
20598 }
20599
20600
20601 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20602 PyObject *resultobj = 0;
20603 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20604 wxEvtHandler *result = 0 ;
20605 void *argp1 = 0 ;
20606 int res1 = 0 ;
20607 PyObject *swig_obj[1] ;
20608
20609 if (!args) SWIG_fail;
20610 swig_obj[0] = args;
20611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20612 if (!SWIG_IsOK(res1)) {
20613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20614 }
20615 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20616 {
20617 PyThreadState* __tstate = wxPyBeginAllowThreads();
20618 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
20619 wxPyEndAllowThreads(__tstate);
20620 if (PyErr_Occurred()) SWIG_fail;
20621 }
20622 {
20623 resultobj = wxPyMake_wxObject(result, 0);
20624 }
20625 return resultobj;
20626 fail:
20627 return NULL;
20628 }
20629
20630
20631 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20632 PyObject *resultobj = 0;
20633 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20634 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20635 void *argp1 = 0 ;
20636 int res1 = 0 ;
20637 void *argp2 = 0 ;
20638 int res2 = 0 ;
20639 PyObject * obj0 = 0 ;
20640 PyObject * obj1 = 0 ;
20641 char * kwnames[] = {
20642 (char *) "self",(char *) "handler", NULL
20643 };
20644
20645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20647 if (!SWIG_IsOK(res1)) {
20648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20649 }
20650 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20651 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20652 if (!SWIG_IsOK(res2)) {
20653 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20654 }
20655 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20656 {
20657 PyThreadState* __tstate = wxPyBeginAllowThreads();
20658 (arg1)->SetNextHandler(arg2);
20659 wxPyEndAllowThreads(__tstate);
20660 if (PyErr_Occurred()) SWIG_fail;
20661 }
20662 resultobj = SWIG_Py_Void();
20663 return resultobj;
20664 fail:
20665 return NULL;
20666 }
20667
20668
20669 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20670 PyObject *resultobj = 0;
20671 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20672 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20673 void *argp1 = 0 ;
20674 int res1 = 0 ;
20675 void *argp2 = 0 ;
20676 int res2 = 0 ;
20677 PyObject * obj0 = 0 ;
20678 PyObject * obj1 = 0 ;
20679 char * kwnames[] = {
20680 (char *) "self",(char *) "handler", NULL
20681 };
20682
20683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20685 if (!SWIG_IsOK(res1)) {
20686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20687 }
20688 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20689 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20690 if (!SWIG_IsOK(res2)) {
20691 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20692 }
20693 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20694 {
20695 PyThreadState* __tstate = wxPyBeginAllowThreads();
20696 (arg1)->SetPreviousHandler(arg2);
20697 wxPyEndAllowThreads(__tstate);
20698 if (PyErr_Occurred()) SWIG_fail;
20699 }
20700 resultobj = SWIG_Py_Void();
20701 return resultobj;
20702 fail:
20703 return NULL;
20704 }
20705
20706
20707 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20708 PyObject *resultobj = 0;
20709 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20710 bool result;
20711 void *argp1 = 0 ;
20712 int res1 = 0 ;
20713 PyObject *swig_obj[1] ;
20714
20715 if (!args) SWIG_fail;
20716 swig_obj[0] = args;
20717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20718 if (!SWIG_IsOK(res1)) {
20719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20720 }
20721 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20722 {
20723 PyThreadState* __tstate = wxPyBeginAllowThreads();
20724 result = (bool)(arg1)->GetEvtHandlerEnabled();
20725 wxPyEndAllowThreads(__tstate);
20726 if (PyErr_Occurred()) SWIG_fail;
20727 }
20728 {
20729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20730 }
20731 return resultobj;
20732 fail:
20733 return NULL;
20734 }
20735
20736
20737 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20738 PyObject *resultobj = 0;
20739 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20740 bool arg2 ;
20741 void *argp1 = 0 ;
20742 int res1 = 0 ;
20743 bool val2 ;
20744 int ecode2 = 0 ;
20745 PyObject * obj0 = 0 ;
20746 PyObject * obj1 = 0 ;
20747 char * kwnames[] = {
20748 (char *) "self",(char *) "enabled", NULL
20749 };
20750
20751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
20752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20753 if (!SWIG_IsOK(res1)) {
20754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20755 }
20756 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20757 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20758 if (!SWIG_IsOK(ecode2)) {
20759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
20760 }
20761 arg2 = static_cast< bool >(val2);
20762 {
20763 PyThreadState* __tstate = wxPyBeginAllowThreads();
20764 (arg1)->SetEvtHandlerEnabled(arg2);
20765 wxPyEndAllowThreads(__tstate);
20766 if (PyErr_Occurred()) SWIG_fail;
20767 }
20768 resultobj = SWIG_Py_Void();
20769 return resultobj;
20770 fail:
20771 return NULL;
20772 }
20773
20774
20775 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20776 PyObject *resultobj = 0;
20777 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20778 wxEvent *arg2 = 0 ;
20779 bool result;
20780 void *argp1 = 0 ;
20781 int res1 = 0 ;
20782 void *argp2 = 0 ;
20783 int res2 = 0 ;
20784 PyObject * obj0 = 0 ;
20785 PyObject * obj1 = 0 ;
20786 char * kwnames[] = {
20787 (char *) "self",(char *) "event", NULL
20788 };
20789
20790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20792 if (!SWIG_IsOK(res1)) {
20793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20794 }
20795 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20796 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20797 if (!SWIG_IsOK(res2)) {
20798 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20799 }
20800 if (!argp2) {
20801 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20802 }
20803 arg2 = reinterpret_cast< wxEvent * >(argp2);
20804 {
20805 PyThreadState* __tstate = wxPyBeginAllowThreads();
20806 result = (bool)(arg1)->ProcessEvent(*arg2);
20807 wxPyEndAllowThreads(__tstate);
20808 if (PyErr_Occurred()) SWIG_fail;
20809 }
20810 {
20811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20812 }
20813 return resultobj;
20814 fail:
20815 return NULL;
20816 }
20817
20818
20819 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20820 PyObject *resultobj = 0;
20821 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20822 wxEvent *arg2 = 0 ;
20823 void *argp1 = 0 ;
20824 int res1 = 0 ;
20825 void *argp2 = 0 ;
20826 int res2 = 0 ;
20827 PyObject * obj0 = 0 ;
20828 PyObject * obj1 = 0 ;
20829 char * kwnames[] = {
20830 (char *) "self",(char *) "event", NULL
20831 };
20832
20833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20835 if (!SWIG_IsOK(res1)) {
20836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20837 }
20838 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20839 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20840 if (!SWIG_IsOK(res2)) {
20841 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20842 }
20843 if (!argp2) {
20844 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20845 }
20846 arg2 = reinterpret_cast< wxEvent * >(argp2);
20847 {
20848 PyThreadState* __tstate = wxPyBeginAllowThreads();
20849 (arg1)->AddPendingEvent(*arg2);
20850 wxPyEndAllowThreads(__tstate);
20851 if (PyErr_Occurred()) SWIG_fail;
20852 }
20853 resultobj = SWIG_Py_Void();
20854 return resultobj;
20855 fail:
20856 return NULL;
20857 }
20858
20859
20860 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20861 PyObject *resultobj = 0;
20862 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20863 void *argp1 = 0 ;
20864 int res1 = 0 ;
20865 PyObject *swig_obj[1] ;
20866
20867 if (!args) SWIG_fail;
20868 swig_obj[0] = args;
20869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20870 if (!SWIG_IsOK(res1)) {
20871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20872 }
20873 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20874 {
20875 PyThreadState* __tstate = wxPyBeginAllowThreads();
20876 (arg1)->ProcessPendingEvents();
20877 wxPyEndAllowThreads(__tstate);
20878 if (PyErr_Occurred()) SWIG_fail;
20879 }
20880 resultobj = SWIG_Py_Void();
20881 return resultobj;
20882 fail:
20883 return NULL;
20884 }
20885
20886
20887 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20888 PyObject *resultobj = 0;
20889 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20890 int arg2 ;
20891 int arg3 ;
20892 int arg4 ;
20893 PyObject *arg5 = (PyObject *) 0 ;
20894 void *argp1 = 0 ;
20895 int res1 = 0 ;
20896 int val2 ;
20897 int ecode2 = 0 ;
20898 int val3 ;
20899 int ecode3 = 0 ;
20900 int val4 ;
20901 int ecode4 = 0 ;
20902 PyObject * obj0 = 0 ;
20903 PyObject * obj1 = 0 ;
20904 PyObject * obj2 = 0 ;
20905 PyObject * obj3 = 0 ;
20906 PyObject * obj4 = 0 ;
20907 char * kwnames[] = {
20908 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
20909 };
20910
20911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
20912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20913 if (!SWIG_IsOK(res1)) {
20914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20915 }
20916 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20917 ecode2 = SWIG_AsVal_int(obj1, &val2);
20918 if (!SWIG_IsOK(ecode2)) {
20919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
20920 }
20921 arg2 = static_cast< int >(val2);
20922 ecode3 = SWIG_AsVal_int(obj2, &val3);
20923 if (!SWIG_IsOK(ecode3)) {
20924 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
20925 }
20926 arg3 = static_cast< int >(val3);
20927 ecode4 = SWIG_AsVal_int(obj3, &val4);
20928 if (!SWIG_IsOK(ecode4)) {
20929 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
20930 }
20931 arg4 = static_cast< int >(val4);
20932 arg5 = obj4;
20933 {
20934 PyThreadState* __tstate = wxPyBeginAllowThreads();
20935 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
20936 wxPyEndAllowThreads(__tstate);
20937 if (PyErr_Occurred()) SWIG_fail;
20938 }
20939 resultobj = SWIG_Py_Void();
20940 return resultobj;
20941 fail:
20942 return NULL;
20943 }
20944
20945
20946 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20947 PyObject *resultobj = 0;
20948 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20949 int arg2 ;
20950 int arg3 = (int) -1 ;
20951 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
20952 bool result;
20953 void *argp1 = 0 ;
20954 int res1 = 0 ;
20955 int val2 ;
20956 int ecode2 = 0 ;
20957 int val3 ;
20958 int ecode3 = 0 ;
20959 int val4 ;
20960 int ecode4 = 0 ;
20961 PyObject * obj0 = 0 ;
20962 PyObject * obj1 = 0 ;
20963 PyObject * obj2 = 0 ;
20964 PyObject * obj3 = 0 ;
20965 char * kwnames[] = {
20966 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
20967 };
20968
20969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20971 if (!SWIG_IsOK(res1)) {
20972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20973 }
20974 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20975 ecode2 = SWIG_AsVal_int(obj1, &val2);
20976 if (!SWIG_IsOK(ecode2)) {
20977 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
20978 }
20979 arg2 = static_cast< int >(val2);
20980 if (obj2) {
20981 ecode3 = SWIG_AsVal_int(obj2, &val3);
20982 if (!SWIG_IsOK(ecode3)) {
20983 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
20984 }
20985 arg3 = static_cast< int >(val3);
20986 }
20987 if (obj3) {
20988 ecode4 = SWIG_AsVal_int(obj3, &val4);
20989 if (!SWIG_IsOK(ecode4)) {
20990 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
20991 }
20992 arg4 = static_cast< wxEventType >(val4);
20993 }
20994 {
20995 PyThreadState* __tstate = wxPyBeginAllowThreads();
20996 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
20997 wxPyEndAllowThreads(__tstate);
20998 if (PyErr_Occurred()) SWIG_fail;
20999 }
21000 {
21001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21002 }
21003 return resultobj;
21004 fail:
21005 return NULL;
21006 }
21007
21008
21009 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21010 PyObject *resultobj = 0;
21011 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21012 PyObject *arg2 = (PyObject *) 0 ;
21013 bool arg3 = (bool) true ;
21014 void *argp1 = 0 ;
21015 int res1 = 0 ;
21016 bool val3 ;
21017 int ecode3 = 0 ;
21018 PyObject * obj0 = 0 ;
21019 PyObject * obj1 = 0 ;
21020 PyObject * obj2 = 0 ;
21021 char * kwnames[] = {
21022 (char *) "self",(char *) "_self",(char *) "incref", NULL
21023 };
21024
21025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21027 if (!SWIG_IsOK(res1)) {
21028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21029 }
21030 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21031 arg2 = obj1;
21032 if (obj2) {
21033 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21034 if (!SWIG_IsOK(ecode3)) {
21035 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
21036 }
21037 arg3 = static_cast< bool >(val3);
21038 }
21039 {
21040 PyThreadState* __tstate = wxPyBeginAllowThreads();
21041 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
21042 wxPyEndAllowThreads(__tstate);
21043 if (PyErr_Occurred()) SWIG_fail;
21044 }
21045 resultobj = SWIG_Py_Void();
21046 return resultobj;
21047 fail:
21048 return NULL;
21049 }
21050
21051
21052 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21053 PyObject *obj;
21054 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21055 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
21056 return SWIG_Py_Void();
21057 }
21058
21059 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21060 return SWIG_Python_InitShadowInstance(args);
21061 }
21062
21063 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21064 PyObject *resultobj = 0;
21065 wxEventType result;
21066
21067 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
21068 {
21069 PyThreadState* __tstate = wxPyBeginAllowThreads();
21070 result = (wxEventType)wxNewEventType();
21071 wxPyEndAllowThreads(__tstate);
21072 if (PyErr_Occurred()) SWIG_fail;
21073 }
21074 resultobj = SWIG_From_int(static_cast< int >(result));
21075 return resultobj;
21076 fail:
21077 return NULL;
21078 }
21079
21080
21081 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21082 PyObject *resultobj = 0;
21083 wxEvent *arg1 = (wxEvent *) 0 ;
21084 void *argp1 = 0 ;
21085 int res1 = 0 ;
21086 PyObject *swig_obj[1] ;
21087
21088 if (!args) SWIG_fail;
21089 swig_obj[0] = args;
21090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
21091 if (!SWIG_IsOK(res1)) {
21092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
21093 }
21094 arg1 = reinterpret_cast< wxEvent * >(argp1);
21095 {
21096 PyThreadState* __tstate = wxPyBeginAllowThreads();
21097 delete arg1;
21098
21099 wxPyEndAllowThreads(__tstate);
21100 if (PyErr_Occurred()) SWIG_fail;
21101 }
21102 resultobj = SWIG_Py_Void();
21103 return resultobj;
21104 fail:
21105 return NULL;
21106 }
21107
21108
21109 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21110 PyObject *resultobj = 0;
21111 wxEvent *arg1 = (wxEvent *) 0 ;
21112 wxEventType arg2 ;
21113 void *argp1 = 0 ;
21114 int res1 = 0 ;
21115 int val2 ;
21116 int ecode2 = 0 ;
21117 PyObject * obj0 = 0 ;
21118 PyObject * obj1 = 0 ;
21119 char * kwnames[] = {
21120 (char *) "self",(char *) "typ", NULL
21121 };
21122
21123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
21124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21125 if (!SWIG_IsOK(res1)) {
21126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
21127 }
21128 arg1 = reinterpret_cast< wxEvent * >(argp1);
21129 ecode2 = SWIG_AsVal_int(obj1, &val2);
21130 if (!SWIG_IsOK(ecode2)) {
21131 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
21132 }
21133 arg2 = static_cast< wxEventType >(val2);
21134 {
21135 PyThreadState* __tstate = wxPyBeginAllowThreads();
21136 (arg1)->SetEventType(arg2);
21137 wxPyEndAllowThreads(__tstate);
21138 if (PyErr_Occurred()) SWIG_fail;
21139 }
21140 resultobj = SWIG_Py_Void();
21141 return resultobj;
21142 fail:
21143 return NULL;
21144 }
21145
21146
21147 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21148 PyObject *resultobj = 0;
21149 wxEvent *arg1 = (wxEvent *) 0 ;
21150 wxEventType result;
21151 void *argp1 = 0 ;
21152 int res1 = 0 ;
21153 PyObject *swig_obj[1] ;
21154
21155 if (!args) SWIG_fail;
21156 swig_obj[0] = args;
21157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21158 if (!SWIG_IsOK(res1)) {
21159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
21160 }
21161 arg1 = reinterpret_cast< wxEvent * >(argp1);
21162 {
21163 PyThreadState* __tstate = wxPyBeginAllowThreads();
21164 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
21165 wxPyEndAllowThreads(__tstate);
21166 if (PyErr_Occurred()) SWIG_fail;
21167 }
21168 resultobj = SWIG_From_int(static_cast< int >(result));
21169 return resultobj;
21170 fail:
21171 return NULL;
21172 }
21173
21174
21175 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21176 PyObject *resultobj = 0;
21177 wxEvent *arg1 = (wxEvent *) 0 ;
21178 wxObject *result = 0 ;
21179 void *argp1 = 0 ;
21180 int res1 = 0 ;
21181 PyObject *swig_obj[1] ;
21182
21183 if (!args) SWIG_fail;
21184 swig_obj[0] = args;
21185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21186 if (!SWIG_IsOK(res1)) {
21187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
21188 }
21189 arg1 = reinterpret_cast< wxEvent * >(argp1);
21190 {
21191 PyThreadState* __tstate = wxPyBeginAllowThreads();
21192 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
21193 wxPyEndAllowThreads(__tstate);
21194 if (PyErr_Occurred()) SWIG_fail;
21195 }
21196 {
21197 resultobj = wxPyMake_wxObject(result, (bool)0);
21198 }
21199 return resultobj;
21200 fail:
21201 return NULL;
21202 }
21203
21204
21205 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21206 PyObject *resultobj = 0;
21207 wxEvent *arg1 = (wxEvent *) 0 ;
21208 wxObject *arg2 = (wxObject *) 0 ;
21209 void *argp1 = 0 ;
21210 int res1 = 0 ;
21211 void *argp2 = 0 ;
21212 int res2 = 0 ;
21213 PyObject * obj0 = 0 ;
21214 PyObject * obj1 = 0 ;
21215 char * kwnames[] = {
21216 (char *) "self",(char *) "obj", NULL
21217 };
21218
21219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
21220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21221 if (!SWIG_IsOK(res1)) {
21222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
21223 }
21224 arg1 = reinterpret_cast< wxEvent * >(argp1);
21225 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
21226 if (!SWIG_IsOK(res2)) {
21227 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
21228 }
21229 arg2 = reinterpret_cast< wxObject * >(argp2);
21230 {
21231 PyThreadState* __tstate = wxPyBeginAllowThreads();
21232 (arg1)->SetEventObject(arg2);
21233 wxPyEndAllowThreads(__tstate);
21234 if (PyErr_Occurred()) SWIG_fail;
21235 }
21236 resultobj = SWIG_Py_Void();
21237 return resultobj;
21238 fail:
21239 return NULL;
21240 }
21241
21242
21243 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21244 PyObject *resultobj = 0;
21245 wxEvent *arg1 = (wxEvent *) 0 ;
21246 long result;
21247 void *argp1 = 0 ;
21248 int res1 = 0 ;
21249 PyObject *swig_obj[1] ;
21250
21251 if (!args) SWIG_fail;
21252 swig_obj[0] = args;
21253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21254 if (!SWIG_IsOK(res1)) {
21255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
21256 }
21257 arg1 = reinterpret_cast< wxEvent * >(argp1);
21258 {
21259 PyThreadState* __tstate = wxPyBeginAllowThreads();
21260 result = (long)((wxEvent const *)arg1)->GetTimestamp();
21261 wxPyEndAllowThreads(__tstate);
21262 if (PyErr_Occurred()) SWIG_fail;
21263 }
21264 resultobj = SWIG_From_long(static_cast< long >(result));
21265 return resultobj;
21266 fail:
21267 return NULL;
21268 }
21269
21270
21271 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21272 PyObject *resultobj = 0;
21273 wxEvent *arg1 = (wxEvent *) 0 ;
21274 long arg2 = (long) 0 ;
21275 void *argp1 = 0 ;
21276 int res1 = 0 ;
21277 long val2 ;
21278 int ecode2 = 0 ;
21279 PyObject * obj0 = 0 ;
21280 PyObject * obj1 = 0 ;
21281 char * kwnames[] = {
21282 (char *) "self",(char *) "ts", NULL
21283 };
21284
21285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
21286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21287 if (!SWIG_IsOK(res1)) {
21288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
21289 }
21290 arg1 = reinterpret_cast< wxEvent * >(argp1);
21291 if (obj1) {
21292 ecode2 = SWIG_AsVal_long(obj1, &val2);
21293 if (!SWIG_IsOK(ecode2)) {
21294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
21295 }
21296 arg2 = static_cast< long >(val2);
21297 }
21298 {
21299 PyThreadState* __tstate = wxPyBeginAllowThreads();
21300 (arg1)->SetTimestamp(arg2);
21301 wxPyEndAllowThreads(__tstate);
21302 if (PyErr_Occurred()) SWIG_fail;
21303 }
21304 resultobj = SWIG_Py_Void();
21305 return resultobj;
21306 fail:
21307 return NULL;
21308 }
21309
21310
21311 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21312 PyObject *resultobj = 0;
21313 wxEvent *arg1 = (wxEvent *) 0 ;
21314 int result;
21315 void *argp1 = 0 ;
21316 int res1 = 0 ;
21317 PyObject *swig_obj[1] ;
21318
21319 if (!args) SWIG_fail;
21320 swig_obj[0] = args;
21321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21322 if (!SWIG_IsOK(res1)) {
21323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
21324 }
21325 arg1 = reinterpret_cast< wxEvent * >(argp1);
21326 {
21327 PyThreadState* __tstate = wxPyBeginAllowThreads();
21328 result = (int)((wxEvent const *)arg1)->GetId();
21329 wxPyEndAllowThreads(__tstate);
21330 if (PyErr_Occurred()) SWIG_fail;
21331 }
21332 resultobj = SWIG_From_int(static_cast< int >(result));
21333 return resultobj;
21334 fail:
21335 return NULL;
21336 }
21337
21338
21339 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21340 PyObject *resultobj = 0;
21341 wxEvent *arg1 = (wxEvent *) 0 ;
21342 int arg2 ;
21343 void *argp1 = 0 ;
21344 int res1 = 0 ;
21345 int val2 ;
21346 int ecode2 = 0 ;
21347 PyObject * obj0 = 0 ;
21348 PyObject * obj1 = 0 ;
21349 char * kwnames[] = {
21350 (char *) "self",(char *) "Id", NULL
21351 };
21352
21353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
21354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21355 if (!SWIG_IsOK(res1)) {
21356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
21357 }
21358 arg1 = reinterpret_cast< wxEvent * >(argp1);
21359 ecode2 = SWIG_AsVal_int(obj1, &val2);
21360 if (!SWIG_IsOK(ecode2)) {
21361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
21362 }
21363 arg2 = static_cast< int >(val2);
21364 {
21365 PyThreadState* __tstate = wxPyBeginAllowThreads();
21366 (arg1)->SetId(arg2);
21367 wxPyEndAllowThreads(__tstate);
21368 if (PyErr_Occurred()) SWIG_fail;
21369 }
21370 resultobj = SWIG_Py_Void();
21371 return resultobj;
21372 fail:
21373 return NULL;
21374 }
21375
21376
21377 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21378 PyObject *resultobj = 0;
21379 wxEvent *arg1 = (wxEvent *) 0 ;
21380 bool result;
21381 void *argp1 = 0 ;
21382 int res1 = 0 ;
21383 PyObject *swig_obj[1] ;
21384
21385 if (!args) SWIG_fail;
21386 swig_obj[0] = args;
21387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21388 if (!SWIG_IsOK(res1)) {
21389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
21390 }
21391 arg1 = reinterpret_cast< wxEvent * >(argp1);
21392 {
21393 PyThreadState* __tstate = wxPyBeginAllowThreads();
21394 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
21395 wxPyEndAllowThreads(__tstate);
21396 if (PyErr_Occurred()) SWIG_fail;
21397 }
21398 {
21399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21400 }
21401 return resultobj;
21402 fail:
21403 return NULL;
21404 }
21405
21406
21407 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21408 PyObject *resultobj = 0;
21409 wxEvent *arg1 = (wxEvent *) 0 ;
21410 bool arg2 = (bool) true ;
21411 void *argp1 = 0 ;
21412 int res1 = 0 ;
21413 bool val2 ;
21414 int ecode2 = 0 ;
21415 PyObject * obj0 = 0 ;
21416 PyObject * obj1 = 0 ;
21417 char * kwnames[] = {
21418 (char *) "self",(char *) "skip", NULL
21419 };
21420
21421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
21422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21423 if (!SWIG_IsOK(res1)) {
21424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
21425 }
21426 arg1 = reinterpret_cast< wxEvent * >(argp1);
21427 if (obj1) {
21428 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21429 if (!SWIG_IsOK(ecode2)) {
21430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
21431 }
21432 arg2 = static_cast< bool >(val2);
21433 }
21434 {
21435 PyThreadState* __tstate = wxPyBeginAllowThreads();
21436 (arg1)->Skip(arg2);
21437 wxPyEndAllowThreads(__tstate);
21438 if (PyErr_Occurred()) SWIG_fail;
21439 }
21440 resultobj = SWIG_Py_Void();
21441 return resultobj;
21442 fail:
21443 return NULL;
21444 }
21445
21446
21447 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21448 PyObject *resultobj = 0;
21449 wxEvent *arg1 = (wxEvent *) 0 ;
21450 bool result;
21451 void *argp1 = 0 ;
21452 int res1 = 0 ;
21453 PyObject *swig_obj[1] ;
21454
21455 if (!args) SWIG_fail;
21456 swig_obj[0] = args;
21457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21458 if (!SWIG_IsOK(res1)) {
21459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
21460 }
21461 arg1 = reinterpret_cast< wxEvent * >(argp1);
21462 {
21463 PyThreadState* __tstate = wxPyBeginAllowThreads();
21464 result = (bool)((wxEvent const *)arg1)->GetSkipped();
21465 wxPyEndAllowThreads(__tstate);
21466 if (PyErr_Occurred()) SWIG_fail;
21467 }
21468 {
21469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21470 }
21471 return resultobj;
21472 fail:
21473 return NULL;
21474 }
21475
21476
21477 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21478 PyObject *resultobj = 0;
21479 wxEvent *arg1 = (wxEvent *) 0 ;
21480 bool result;
21481 void *argp1 = 0 ;
21482 int res1 = 0 ;
21483 PyObject *swig_obj[1] ;
21484
21485 if (!args) SWIG_fail;
21486 swig_obj[0] = args;
21487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21488 if (!SWIG_IsOK(res1)) {
21489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
21490 }
21491 arg1 = reinterpret_cast< wxEvent * >(argp1);
21492 {
21493 PyThreadState* __tstate = wxPyBeginAllowThreads();
21494 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
21495 wxPyEndAllowThreads(__tstate);
21496 if (PyErr_Occurred()) SWIG_fail;
21497 }
21498 {
21499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21500 }
21501 return resultobj;
21502 fail:
21503 return NULL;
21504 }
21505
21506
21507 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21508 PyObject *resultobj = 0;
21509 wxEvent *arg1 = (wxEvent *) 0 ;
21510 int result;
21511 void *argp1 = 0 ;
21512 int res1 = 0 ;
21513 PyObject *swig_obj[1] ;
21514
21515 if (!args) SWIG_fail;
21516 swig_obj[0] = args;
21517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21518 if (!SWIG_IsOK(res1)) {
21519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21520 }
21521 arg1 = reinterpret_cast< wxEvent * >(argp1);
21522 {
21523 PyThreadState* __tstate = wxPyBeginAllowThreads();
21524 result = (int)(arg1)->StopPropagation();
21525 wxPyEndAllowThreads(__tstate);
21526 if (PyErr_Occurred()) SWIG_fail;
21527 }
21528 resultobj = SWIG_From_int(static_cast< int >(result));
21529 return resultobj;
21530 fail:
21531 return NULL;
21532 }
21533
21534
21535 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21536 PyObject *resultobj = 0;
21537 wxEvent *arg1 = (wxEvent *) 0 ;
21538 int arg2 ;
21539 void *argp1 = 0 ;
21540 int res1 = 0 ;
21541 int val2 ;
21542 int ecode2 = 0 ;
21543 PyObject * obj0 = 0 ;
21544 PyObject * obj1 = 0 ;
21545 char * kwnames[] = {
21546 (char *) "self",(char *) "propagationLevel", NULL
21547 };
21548
21549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
21550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21551 if (!SWIG_IsOK(res1)) {
21552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21553 }
21554 arg1 = reinterpret_cast< wxEvent * >(argp1);
21555 ecode2 = SWIG_AsVal_int(obj1, &val2);
21556 if (!SWIG_IsOK(ecode2)) {
21557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
21558 }
21559 arg2 = static_cast< int >(val2);
21560 {
21561 PyThreadState* __tstate = wxPyBeginAllowThreads();
21562 (arg1)->ResumePropagation(arg2);
21563 wxPyEndAllowThreads(__tstate);
21564 if (PyErr_Occurred()) SWIG_fail;
21565 }
21566 resultobj = SWIG_Py_Void();
21567 return resultobj;
21568 fail:
21569 return NULL;
21570 }
21571
21572
21573 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21574 PyObject *resultobj = 0;
21575 wxEvent *arg1 = (wxEvent *) 0 ;
21576 wxEvent *result = 0 ;
21577 void *argp1 = 0 ;
21578 int res1 = 0 ;
21579 PyObject *swig_obj[1] ;
21580
21581 if (!args) SWIG_fail;
21582 swig_obj[0] = args;
21583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21584 if (!SWIG_IsOK(res1)) {
21585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
21586 }
21587 arg1 = reinterpret_cast< wxEvent * >(argp1);
21588 {
21589 PyThreadState* __tstate = wxPyBeginAllowThreads();
21590 result = (wxEvent *)(arg1)->Clone();
21591 wxPyEndAllowThreads(__tstate);
21592 if (PyErr_Occurred()) SWIG_fail;
21593 }
21594 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
21595 return resultobj;
21596 fail:
21597 return NULL;
21598 }
21599
21600
21601 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21602 PyObject *obj;
21603 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21604 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
21605 return SWIG_Py_Void();
21606 }
21607
21608 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21609 PyObject *resultobj = 0;
21610 wxEvent *arg1 = 0 ;
21611 wxPropagationDisabler *result = 0 ;
21612 void *argp1 = 0 ;
21613 int res1 = 0 ;
21614 PyObject * obj0 = 0 ;
21615 char * kwnames[] = {
21616 (char *) "event", NULL
21617 };
21618
21619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
21620 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21621 if (!SWIG_IsOK(res1)) {
21622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21623 }
21624 if (!argp1) {
21625 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21626 }
21627 arg1 = reinterpret_cast< wxEvent * >(argp1);
21628 {
21629 PyThreadState* __tstate = wxPyBeginAllowThreads();
21630 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
21631 wxPyEndAllowThreads(__tstate);
21632 if (PyErr_Occurred()) SWIG_fail;
21633 }
21634 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
21635 return resultobj;
21636 fail:
21637 return NULL;
21638 }
21639
21640
21641 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21642 PyObject *resultobj = 0;
21643 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
21644 void *argp1 = 0 ;
21645 int res1 = 0 ;
21646 PyObject *swig_obj[1] ;
21647
21648 if (!args) SWIG_fail;
21649 swig_obj[0] = args;
21650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
21651 if (!SWIG_IsOK(res1)) {
21652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
21653 }
21654 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
21655 {
21656 PyThreadState* __tstate = wxPyBeginAllowThreads();
21657 delete arg1;
21658
21659 wxPyEndAllowThreads(__tstate);
21660 if (PyErr_Occurred()) SWIG_fail;
21661 }
21662 resultobj = SWIG_Py_Void();
21663 return resultobj;
21664 fail:
21665 return NULL;
21666 }
21667
21668
21669 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21670 PyObject *obj;
21671 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21672 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
21673 return SWIG_Py_Void();
21674 }
21675
21676 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21677 return SWIG_Python_InitShadowInstance(args);
21678 }
21679
21680 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21681 PyObject *resultobj = 0;
21682 wxEvent *arg1 = 0 ;
21683 wxPropagateOnce *result = 0 ;
21684 void *argp1 = 0 ;
21685 int res1 = 0 ;
21686 PyObject * obj0 = 0 ;
21687 char * kwnames[] = {
21688 (char *) "event", NULL
21689 };
21690
21691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
21692 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21693 if (!SWIG_IsOK(res1)) {
21694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21695 }
21696 if (!argp1) {
21697 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21698 }
21699 arg1 = reinterpret_cast< wxEvent * >(argp1);
21700 {
21701 PyThreadState* __tstate = wxPyBeginAllowThreads();
21702 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
21703 wxPyEndAllowThreads(__tstate);
21704 if (PyErr_Occurred()) SWIG_fail;
21705 }
21706 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
21707 return resultobj;
21708 fail:
21709 return NULL;
21710 }
21711
21712
21713 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21714 PyObject *resultobj = 0;
21715 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
21716 void *argp1 = 0 ;
21717 int res1 = 0 ;
21718 PyObject *swig_obj[1] ;
21719
21720 if (!args) SWIG_fail;
21721 swig_obj[0] = args;
21722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
21723 if (!SWIG_IsOK(res1)) {
21724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
21725 }
21726 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
21727 {
21728 PyThreadState* __tstate = wxPyBeginAllowThreads();
21729 delete arg1;
21730
21731 wxPyEndAllowThreads(__tstate);
21732 if (PyErr_Occurred()) SWIG_fail;
21733 }
21734 resultobj = SWIG_Py_Void();
21735 return resultobj;
21736 fail:
21737 return NULL;
21738 }
21739
21740
21741 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21742 PyObject *obj;
21743 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21744 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
21745 return SWIG_Py_Void();
21746 }
21747
21748 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21749 return SWIG_Python_InitShadowInstance(args);
21750 }
21751
21752 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21753 PyObject *resultobj = 0;
21754 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21755 int arg2 = (int) 0 ;
21756 wxCommandEvent *result = 0 ;
21757 int val1 ;
21758 int ecode1 = 0 ;
21759 int val2 ;
21760 int ecode2 = 0 ;
21761 PyObject * obj0 = 0 ;
21762 PyObject * obj1 = 0 ;
21763 char * kwnames[] = {
21764 (char *) "commandType",(char *) "winid", NULL
21765 };
21766
21767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21768 if (obj0) {
21769 ecode1 = SWIG_AsVal_int(obj0, &val1);
21770 if (!SWIG_IsOK(ecode1)) {
21771 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21772 }
21773 arg1 = static_cast< wxEventType >(val1);
21774 }
21775 if (obj1) {
21776 ecode2 = SWIG_AsVal_int(obj1, &val2);
21777 if (!SWIG_IsOK(ecode2)) {
21778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
21779 }
21780 arg2 = static_cast< int >(val2);
21781 }
21782 {
21783 PyThreadState* __tstate = wxPyBeginAllowThreads();
21784 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
21785 wxPyEndAllowThreads(__tstate);
21786 if (PyErr_Occurred()) SWIG_fail;
21787 }
21788 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
21789 return resultobj;
21790 fail:
21791 return NULL;
21792 }
21793
21794
21795 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21796 PyObject *resultobj = 0;
21797 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21798 int result;
21799 void *argp1 = 0 ;
21800 int res1 = 0 ;
21801 PyObject *swig_obj[1] ;
21802
21803 if (!args) SWIG_fail;
21804 swig_obj[0] = args;
21805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21806 if (!SWIG_IsOK(res1)) {
21807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21808 }
21809 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21810 {
21811 PyThreadState* __tstate = wxPyBeginAllowThreads();
21812 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
21813 wxPyEndAllowThreads(__tstate);
21814 if (PyErr_Occurred()) SWIG_fail;
21815 }
21816 resultobj = SWIG_From_int(static_cast< int >(result));
21817 return resultobj;
21818 fail:
21819 return NULL;
21820 }
21821
21822
21823 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21824 PyObject *resultobj = 0;
21825 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21826 wxString *arg2 = 0 ;
21827 void *argp1 = 0 ;
21828 int res1 = 0 ;
21829 bool temp2 = false ;
21830 PyObject * obj0 = 0 ;
21831 PyObject * obj1 = 0 ;
21832 char * kwnames[] = {
21833 (char *) "self",(char *) "s", NULL
21834 };
21835
21836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
21837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21838 if (!SWIG_IsOK(res1)) {
21839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
21840 }
21841 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21842 {
21843 arg2 = wxString_in_helper(obj1);
21844 if (arg2 == NULL) SWIG_fail;
21845 temp2 = true;
21846 }
21847 {
21848 PyThreadState* __tstate = wxPyBeginAllowThreads();
21849 (arg1)->SetString((wxString const &)*arg2);
21850 wxPyEndAllowThreads(__tstate);
21851 if (PyErr_Occurred()) SWIG_fail;
21852 }
21853 resultobj = SWIG_Py_Void();
21854 {
21855 if (temp2)
21856 delete arg2;
21857 }
21858 return resultobj;
21859 fail:
21860 {
21861 if (temp2)
21862 delete arg2;
21863 }
21864 return NULL;
21865 }
21866
21867
21868 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21869 PyObject *resultobj = 0;
21870 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21871 wxString result;
21872 void *argp1 = 0 ;
21873 int res1 = 0 ;
21874 PyObject *swig_obj[1] ;
21875
21876 if (!args) SWIG_fail;
21877 swig_obj[0] = args;
21878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21879 if (!SWIG_IsOK(res1)) {
21880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21881 }
21882 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21883 {
21884 PyThreadState* __tstate = wxPyBeginAllowThreads();
21885 result = ((wxCommandEvent const *)arg1)->GetString();
21886 wxPyEndAllowThreads(__tstate);
21887 if (PyErr_Occurred()) SWIG_fail;
21888 }
21889 {
21890 #if wxUSE_UNICODE
21891 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21892 #else
21893 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21894 #endif
21895 }
21896 return resultobj;
21897 fail:
21898 return NULL;
21899 }
21900
21901
21902 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21903 PyObject *resultobj = 0;
21904 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21905 bool result;
21906 void *argp1 = 0 ;
21907 int res1 = 0 ;
21908 PyObject *swig_obj[1] ;
21909
21910 if (!args) SWIG_fail;
21911 swig_obj[0] = args;
21912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21913 if (!SWIG_IsOK(res1)) {
21914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21915 }
21916 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21917 {
21918 PyThreadState* __tstate = wxPyBeginAllowThreads();
21919 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
21920 wxPyEndAllowThreads(__tstate);
21921 if (PyErr_Occurred()) SWIG_fail;
21922 }
21923 {
21924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21925 }
21926 return resultobj;
21927 fail:
21928 return NULL;
21929 }
21930
21931
21932 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21933 PyObject *resultobj = 0;
21934 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21935 bool result;
21936 void *argp1 = 0 ;
21937 int res1 = 0 ;
21938 PyObject *swig_obj[1] ;
21939
21940 if (!args) SWIG_fail;
21941 swig_obj[0] = args;
21942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21943 if (!SWIG_IsOK(res1)) {
21944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21945 }
21946 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21947 {
21948 PyThreadState* __tstate = wxPyBeginAllowThreads();
21949 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
21950 wxPyEndAllowThreads(__tstate);
21951 if (PyErr_Occurred()) SWIG_fail;
21952 }
21953 {
21954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21955 }
21956 return resultobj;
21957 fail:
21958 return NULL;
21959 }
21960
21961
21962 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21963 PyObject *resultobj = 0;
21964 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21965 long arg2 ;
21966 void *argp1 = 0 ;
21967 int res1 = 0 ;
21968 long val2 ;
21969 int ecode2 = 0 ;
21970 PyObject * obj0 = 0 ;
21971 PyObject * obj1 = 0 ;
21972 char * kwnames[] = {
21973 (char *) "self",(char *) "extraLong", NULL
21974 };
21975
21976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
21977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21978 if (!SWIG_IsOK(res1)) {
21979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
21980 }
21981 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21982 ecode2 = SWIG_AsVal_long(obj1, &val2);
21983 if (!SWIG_IsOK(ecode2)) {
21984 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
21985 }
21986 arg2 = static_cast< long >(val2);
21987 {
21988 PyThreadState* __tstate = wxPyBeginAllowThreads();
21989 (arg1)->SetExtraLong(arg2);
21990 wxPyEndAllowThreads(__tstate);
21991 if (PyErr_Occurred()) SWIG_fail;
21992 }
21993 resultobj = SWIG_Py_Void();
21994 return resultobj;
21995 fail:
21996 return NULL;
21997 }
21998
21999
22000 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22001 PyObject *resultobj = 0;
22002 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22003 long result;
22004 void *argp1 = 0 ;
22005 int res1 = 0 ;
22006 PyObject *swig_obj[1] ;
22007
22008 if (!args) SWIG_fail;
22009 swig_obj[0] = args;
22010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22011 if (!SWIG_IsOK(res1)) {
22012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22013 }
22014 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22015 {
22016 PyThreadState* __tstate = wxPyBeginAllowThreads();
22017 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
22018 wxPyEndAllowThreads(__tstate);
22019 if (PyErr_Occurred()) SWIG_fail;
22020 }
22021 resultobj = SWIG_From_long(static_cast< long >(result));
22022 return resultobj;
22023 fail:
22024 return NULL;
22025 }
22026
22027
22028 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22029 PyObject *resultobj = 0;
22030 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22031 int arg2 ;
22032 void *argp1 = 0 ;
22033 int res1 = 0 ;
22034 int val2 ;
22035 int ecode2 = 0 ;
22036 PyObject * obj0 = 0 ;
22037 PyObject * obj1 = 0 ;
22038 char * kwnames[] = {
22039 (char *) "self",(char *) "i", NULL
22040 };
22041
22042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
22043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22044 if (!SWIG_IsOK(res1)) {
22045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22046 }
22047 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22048 ecode2 = SWIG_AsVal_int(obj1, &val2);
22049 if (!SWIG_IsOK(ecode2)) {
22050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
22051 }
22052 arg2 = static_cast< int >(val2);
22053 {
22054 PyThreadState* __tstate = wxPyBeginAllowThreads();
22055 (arg1)->SetInt(arg2);
22056 wxPyEndAllowThreads(__tstate);
22057 if (PyErr_Occurred()) SWIG_fail;
22058 }
22059 resultobj = SWIG_Py_Void();
22060 return resultobj;
22061 fail:
22062 return NULL;
22063 }
22064
22065
22066 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22067 PyObject *resultobj = 0;
22068 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22069 int result;
22070 void *argp1 = 0 ;
22071 int res1 = 0 ;
22072 PyObject *swig_obj[1] ;
22073
22074 if (!args) SWIG_fail;
22075 swig_obj[0] = args;
22076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22077 if (!SWIG_IsOK(res1)) {
22078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22079 }
22080 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22081 {
22082 PyThreadState* __tstate = wxPyBeginAllowThreads();
22083 result = (int)((wxCommandEvent const *)arg1)->GetInt();
22084 wxPyEndAllowThreads(__tstate);
22085 if (PyErr_Occurred()) SWIG_fail;
22086 }
22087 resultobj = SWIG_From_int(static_cast< int >(result));
22088 return resultobj;
22089 fail:
22090 return NULL;
22091 }
22092
22093
22094 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22095 PyObject *resultobj = 0;
22096 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22097 PyObject *result = 0 ;
22098 void *argp1 = 0 ;
22099 int res1 = 0 ;
22100 PyObject *swig_obj[1] ;
22101
22102 if (!args) SWIG_fail;
22103 swig_obj[0] = args;
22104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22105 if (!SWIG_IsOK(res1)) {
22106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22107 }
22108 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22109 {
22110 PyThreadState* __tstate = wxPyBeginAllowThreads();
22111 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
22112 wxPyEndAllowThreads(__tstate);
22113 if (PyErr_Occurred()) SWIG_fail;
22114 }
22115 resultobj = result;
22116 return resultobj;
22117 fail:
22118 return NULL;
22119 }
22120
22121
22122 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22123 PyObject *resultobj = 0;
22124 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22125 PyObject *arg2 = (PyObject *) 0 ;
22126 void *argp1 = 0 ;
22127 int res1 = 0 ;
22128 PyObject * obj0 = 0 ;
22129 PyObject * obj1 = 0 ;
22130 char * kwnames[] = {
22131 (char *) "self",(char *) "clientData", NULL
22132 };
22133
22134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
22135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22136 if (!SWIG_IsOK(res1)) {
22137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22138 }
22139 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22140 arg2 = obj1;
22141 {
22142 PyThreadState* __tstate = wxPyBeginAllowThreads();
22143 wxCommandEvent_SetClientData(arg1,arg2);
22144 wxPyEndAllowThreads(__tstate);
22145 if (PyErr_Occurred()) SWIG_fail;
22146 }
22147 resultobj = SWIG_Py_Void();
22148 return resultobj;
22149 fail:
22150 return NULL;
22151 }
22152
22153
22154 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22155 PyObject *resultobj = 0;
22156 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22157 wxEvent *result = 0 ;
22158 void *argp1 = 0 ;
22159 int res1 = 0 ;
22160 PyObject *swig_obj[1] ;
22161
22162 if (!args) SWIG_fail;
22163 swig_obj[0] = args;
22164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22165 if (!SWIG_IsOK(res1)) {
22166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22167 }
22168 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22169 {
22170 PyThreadState* __tstate = wxPyBeginAllowThreads();
22171 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
22172 wxPyEndAllowThreads(__tstate);
22173 if (PyErr_Occurred()) SWIG_fail;
22174 }
22175 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
22176 return resultobj;
22177 fail:
22178 return NULL;
22179 }
22180
22181
22182 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22183 PyObject *obj;
22184 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22185 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
22186 return SWIG_Py_Void();
22187 }
22188
22189 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22190 return SWIG_Python_InitShadowInstance(args);
22191 }
22192
22193 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22194 PyObject *resultobj = 0;
22195 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22196 int arg2 = (int) 0 ;
22197 wxNotifyEvent *result = 0 ;
22198 int val1 ;
22199 int ecode1 = 0 ;
22200 int val2 ;
22201 int ecode2 = 0 ;
22202 PyObject * obj0 = 0 ;
22203 PyObject * obj1 = 0 ;
22204 char * kwnames[] = {
22205 (char *) "commandType",(char *) "winid", NULL
22206 };
22207
22208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22209 if (obj0) {
22210 ecode1 = SWIG_AsVal_int(obj0, &val1);
22211 if (!SWIG_IsOK(ecode1)) {
22212 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22213 }
22214 arg1 = static_cast< wxEventType >(val1);
22215 }
22216 if (obj1) {
22217 ecode2 = SWIG_AsVal_int(obj1, &val2);
22218 if (!SWIG_IsOK(ecode2)) {
22219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
22220 }
22221 arg2 = static_cast< int >(val2);
22222 }
22223 {
22224 PyThreadState* __tstate = wxPyBeginAllowThreads();
22225 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
22226 wxPyEndAllowThreads(__tstate);
22227 if (PyErr_Occurred()) SWIG_fail;
22228 }
22229 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
22230 return resultobj;
22231 fail:
22232 return NULL;
22233 }
22234
22235
22236 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22237 PyObject *resultobj = 0;
22238 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22239 void *argp1 = 0 ;
22240 int res1 = 0 ;
22241 PyObject *swig_obj[1] ;
22242
22243 if (!args) SWIG_fail;
22244 swig_obj[0] = args;
22245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22246 if (!SWIG_IsOK(res1)) {
22247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22248 }
22249 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22250 {
22251 PyThreadState* __tstate = wxPyBeginAllowThreads();
22252 (arg1)->Veto();
22253 wxPyEndAllowThreads(__tstate);
22254 if (PyErr_Occurred()) SWIG_fail;
22255 }
22256 resultobj = SWIG_Py_Void();
22257 return resultobj;
22258 fail:
22259 return NULL;
22260 }
22261
22262
22263 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22264 PyObject *resultobj = 0;
22265 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22266 void *argp1 = 0 ;
22267 int res1 = 0 ;
22268 PyObject *swig_obj[1] ;
22269
22270 if (!args) SWIG_fail;
22271 swig_obj[0] = args;
22272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22273 if (!SWIG_IsOK(res1)) {
22274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22275 }
22276 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22277 {
22278 PyThreadState* __tstate = wxPyBeginAllowThreads();
22279 (arg1)->Allow();
22280 wxPyEndAllowThreads(__tstate);
22281 if (PyErr_Occurred()) SWIG_fail;
22282 }
22283 resultobj = SWIG_Py_Void();
22284 return resultobj;
22285 fail:
22286 return NULL;
22287 }
22288
22289
22290 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22291 PyObject *resultobj = 0;
22292 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22293 bool result;
22294 void *argp1 = 0 ;
22295 int res1 = 0 ;
22296 PyObject *swig_obj[1] ;
22297
22298 if (!args) SWIG_fail;
22299 swig_obj[0] = args;
22300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22301 if (!SWIG_IsOK(res1)) {
22302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22303 }
22304 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22305 {
22306 PyThreadState* __tstate = wxPyBeginAllowThreads();
22307 result = (bool)(arg1)->IsAllowed();
22308 wxPyEndAllowThreads(__tstate);
22309 if (PyErr_Occurred()) SWIG_fail;
22310 }
22311 {
22312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22313 }
22314 return resultobj;
22315 fail:
22316 return NULL;
22317 }
22318
22319
22320 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22321 PyObject *obj;
22322 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22323 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
22324 return SWIG_Py_Void();
22325 }
22326
22327 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22328 return SWIG_Python_InitShadowInstance(args);
22329 }
22330
22331 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22332 PyObject *resultobj = 0;
22333 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22334 int arg2 = (int) 0 ;
22335 int arg3 = (int) 0 ;
22336 int arg4 = (int) 0 ;
22337 wxScrollEvent *result = 0 ;
22338 int val1 ;
22339 int ecode1 = 0 ;
22340 int val2 ;
22341 int ecode2 = 0 ;
22342 int val3 ;
22343 int ecode3 = 0 ;
22344 int val4 ;
22345 int ecode4 = 0 ;
22346 PyObject * obj0 = 0 ;
22347 PyObject * obj1 = 0 ;
22348 PyObject * obj2 = 0 ;
22349 PyObject * obj3 = 0 ;
22350 char * kwnames[] = {
22351 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
22352 };
22353
22354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22355 if (obj0) {
22356 ecode1 = SWIG_AsVal_int(obj0, &val1);
22357 if (!SWIG_IsOK(ecode1)) {
22358 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22359 }
22360 arg1 = static_cast< wxEventType >(val1);
22361 }
22362 if (obj1) {
22363 ecode2 = SWIG_AsVal_int(obj1, &val2);
22364 if (!SWIG_IsOK(ecode2)) {
22365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
22366 }
22367 arg2 = static_cast< int >(val2);
22368 }
22369 if (obj2) {
22370 ecode3 = SWIG_AsVal_int(obj2, &val3);
22371 if (!SWIG_IsOK(ecode3)) {
22372 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
22373 }
22374 arg3 = static_cast< int >(val3);
22375 }
22376 if (obj3) {
22377 ecode4 = SWIG_AsVal_int(obj3, &val4);
22378 if (!SWIG_IsOK(ecode4)) {
22379 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
22380 }
22381 arg4 = static_cast< int >(val4);
22382 }
22383 {
22384 PyThreadState* __tstate = wxPyBeginAllowThreads();
22385 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
22386 wxPyEndAllowThreads(__tstate);
22387 if (PyErr_Occurred()) SWIG_fail;
22388 }
22389 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
22390 return resultobj;
22391 fail:
22392 return NULL;
22393 }
22394
22395
22396 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22397 PyObject *resultobj = 0;
22398 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22399 int result;
22400 void *argp1 = 0 ;
22401 int res1 = 0 ;
22402 PyObject *swig_obj[1] ;
22403
22404 if (!args) SWIG_fail;
22405 swig_obj[0] = args;
22406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22407 if (!SWIG_IsOK(res1)) {
22408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22409 }
22410 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22411 {
22412 PyThreadState* __tstate = wxPyBeginAllowThreads();
22413 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
22414 wxPyEndAllowThreads(__tstate);
22415 if (PyErr_Occurred()) SWIG_fail;
22416 }
22417 resultobj = SWIG_From_int(static_cast< int >(result));
22418 return resultobj;
22419 fail:
22420 return NULL;
22421 }
22422
22423
22424 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22425 PyObject *resultobj = 0;
22426 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22427 int result;
22428 void *argp1 = 0 ;
22429 int res1 = 0 ;
22430 PyObject *swig_obj[1] ;
22431
22432 if (!args) SWIG_fail;
22433 swig_obj[0] = args;
22434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22435 if (!SWIG_IsOK(res1)) {
22436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22437 }
22438 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22439 {
22440 PyThreadState* __tstate = wxPyBeginAllowThreads();
22441 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
22442 wxPyEndAllowThreads(__tstate);
22443 if (PyErr_Occurred()) SWIG_fail;
22444 }
22445 resultobj = SWIG_From_int(static_cast< int >(result));
22446 return resultobj;
22447 fail:
22448 return NULL;
22449 }
22450
22451
22452 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22453 PyObject *resultobj = 0;
22454 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22455 int arg2 ;
22456 void *argp1 = 0 ;
22457 int res1 = 0 ;
22458 int val2 ;
22459 int ecode2 = 0 ;
22460 PyObject * obj0 = 0 ;
22461 PyObject * obj1 = 0 ;
22462 char * kwnames[] = {
22463 (char *) "self",(char *) "orient", NULL
22464 };
22465
22466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22468 if (!SWIG_IsOK(res1)) {
22469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22470 }
22471 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22472 ecode2 = SWIG_AsVal_int(obj1, &val2);
22473 if (!SWIG_IsOK(ecode2)) {
22474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22475 }
22476 arg2 = static_cast< int >(val2);
22477 {
22478 PyThreadState* __tstate = wxPyBeginAllowThreads();
22479 (arg1)->SetOrientation(arg2);
22480 wxPyEndAllowThreads(__tstate);
22481 if (PyErr_Occurred()) SWIG_fail;
22482 }
22483 resultobj = SWIG_Py_Void();
22484 return resultobj;
22485 fail:
22486 return NULL;
22487 }
22488
22489
22490 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22491 PyObject *resultobj = 0;
22492 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22493 int arg2 ;
22494 void *argp1 = 0 ;
22495 int res1 = 0 ;
22496 int val2 ;
22497 int ecode2 = 0 ;
22498 PyObject * obj0 = 0 ;
22499 PyObject * obj1 = 0 ;
22500 char * kwnames[] = {
22501 (char *) "self",(char *) "pos", NULL
22502 };
22503
22504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22506 if (!SWIG_IsOK(res1)) {
22507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22508 }
22509 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22510 ecode2 = SWIG_AsVal_int(obj1, &val2);
22511 if (!SWIG_IsOK(ecode2)) {
22512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22513 }
22514 arg2 = static_cast< int >(val2);
22515 {
22516 PyThreadState* __tstate = wxPyBeginAllowThreads();
22517 (arg1)->SetPosition(arg2);
22518 wxPyEndAllowThreads(__tstate);
22519 if (PyErr_Occurred()) SWIG_fail;
22520 }
22521 resultobj = SWIG_Py_Void();
22522 return resultobj;
22523 fail:
22524 return NULL;
22525 }
22526
22527
22528 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22529 PyObject *obj;
22530 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22531 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
22532 return SWIG_Py_Void();
22533 }
22534
22535 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22536 return SWIG_Python_InitShadowInstance(args);
22537 }
22538
22539 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22540 PyObject *resultobj = 0;
22541 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22542 int arg2 = (int) 0 ;
22543 int arg3 = (int) 0 ;
22544 wxScrollWinEvent *result = 0 ;
22545 int val1 ;
22546 int ecode1 = 0 ;
22547 int val2 ;
22548 int ecode2 = 0 ;
22549 int val3 ;
22550 int ecode3 = 0 ;
22551 PyObject * obj0 = 0 ;
22552 PyObject * obj1 = 0 ;
22553 PyObject * obj2 = 0 ;
22554 char * kwnames[] = {
22555 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
22556 };
22557
22558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22559 if (obj0) {
22560 ecode1 = SWIG_AsVal_int(obj0, &val1);
22561 if (!SWIG_IsOK(ecode1)) {
22562 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22563 }
22564 arg1 = static_cast< wxEventType >(val1);
22565 }
22566 if (obj1) {
22567 ecode2 = SWIG_AsVal_int(obj1, &val2);
22568 if (!SWIG_IsOK(ecode2)) {
22569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
22570 }
22571 arg2 = static_cast< int >(val2);
22572 }
22573 if (obj2) {
22574 ecode3 = SWIG_AsVal_int(obj2, &val3);
22575 if (!SWIG_IsOK(ecode3)) {
22576 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
22577 }
22578 arg3 = static_cast< int >(val3);
22579 }
22580 {
22581 PyThreadState* __tstate = wxPyBeginAllowThreads();
22582 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
22583 wxPyEndAllowThreads(__tstate);
22584 if (PyErr_Occurred()) SWIG_fail;
22585 }
22586 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
22587 return resultobj;
22588 fail:
22589 return NULL;
22590 }
22591
22592
22593 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22594 PyObject *resultobj = 0;
22595 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22596 int result;
22597 void *argp1 = 0 ;
22598 int res1 = 0 ;
22599 PyObject *swig_obj[1] ;
22600
22601 if (!args) SWIG_fail;
22602 swig_obj[0] = args;
22603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22604 if (!SWIG_IsOK(res1)) {
22605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22606 }
22607 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22608 {
22609 PyThreadState* __tstate = wxPyBeginAllowThreads();
22610 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
22611 wxPyEndAllowThreads(__tstate);
22612 if (PyErr_Occurred()) SWIG_fail;
22613 }
22614 resultobj = SWIG_From_int(static_cast< int >(result));
22615 return resultobj;
22616 fail:
22617 return NULL;
22618 }
22619
22620
22621 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22622 PyObject *resultobj = 0;
22623 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22624 int result;
22625 void *argp1 = 0 ;
22626 int res1 = 0 ;
22627 PyObject *swig_obj[1] ;
22628
22629 if (!args) SWIG_fail;
22630 swig_obj[0] = args;
22631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22632 if (!SWIG_IsOK(res1)) {
22633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22634 }
22635 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22636 {
22637 PyThreadState* __tstate = wxPyBeginAllowThreads();
22638 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
22639 wxPyEndAllowThreads(__tstate);
22640 if (PyErr_Occurred()) SWIG_fail;
22641 }
22642 resultobj = SWIG_From_int(static_cast< int >(result));
22643 return resultobj;
22644 fail:
22645 return NULL;
22646 }
22647
22648
22649 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22650 PyObject *resultobj = 0;
22651 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22652 int arg2 ;
22653 void *argp1 = 0 ;
22654 int res1 = 0 ;
22655 int val2 ;
22656 int ecode2 = 0 ;
22657 PyObject * obj0 = 0 ;
22658 PyObject * obj1 = 0 ;
22659 char * kwnames[] = {
22660 (char *) "self",(char *) "orient", NULL
22661 };
22662
22663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22665 if (!SWIG_IsOK(res1)) {
22666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22667 }
22668 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22669 ecode2 = SWIG_AsVal_int(obj1, &val2);
22670 if (!SWIG_IsOK(ecode2)) {
22671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22672 }
22673 arg2 = static_cast< int >(val2);
22674 {
22675 PyThreadState* __tstate = wxPyBeginAllowThreads();
22676 (arg1)->SetOrientation(arg2);
22677 wxPyEndAllowThreads(__tstate);
22678 if (PyErr_Occurred()) SWIG_fail;
22679 }
22680 resultobj = SWIG_Py_Void();
22681 return resultobj;
22682 fail:
22683 return NULL;
22684 }
22685
22686
22687 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22688 PyObject *resultobj = 0;
22689 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22690 int arg2 ;
22691 void *argp1 = 0 ;
22692 int res1 = 0 ;
22693 int val2 ;
22694 int ecode2 = 0 ;
22695 PyObject * obj0 = 0 ;
22696 PyObject * obj1 = 0 ;
22697 char * kwnames[] = {
22698 (char *) "self",(char *) "pos", NULL
22699 };
22700
22701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22703 if (!SWIG_IsOK(res1)) {
22704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22705 }
22706 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22707 ecode2 = SWIG_AsVal_int(obj1, &val2);
22708 if (!SWIG_IsOK(ecode2)) {
22709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22710 }
22711 arg2 = static_cast< int >(val2);
22712 {
22713 PyThreadState* __tstate = wxPyBeginAllowThreads();
22714 (arg1)->SetPosition(arg2);
22715 wxPyEndAllowThreads(__tstate);
22716 if (PyErr_Occurred()) SWIG_fail;
22717 }
22718 resultobj = SWIG_Py_Void();
22719 return resultobj;
22720 fail:
22721 return NULL;
22722 }
22723
22724
22725 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22726 PyObject *obj;
22727 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22728 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
22729 return SWIG_Py_Void();
22730 }
22731
22732 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22733 return SWIG_Python_InitShadowInstance(args);
22734 }
22735
22736 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22737 PyObject *resultobj = 0;
22738 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22739 wxMouseEvent *result = 0 ;
22740 int val1 ;
22741 int ecode1 = 0 ;
22742 PyObject * obj0 = 0 ;
22743 char * kwnames[] = {
22744 (char *) "mouseType", NULL
22745 };
22746
22747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
22748 if (obj0) {
22749 ecode1 = SWIG_AsVal_int(obj0, &val1);
22750 if (!SWIG_IsOK(ecode1)) {
22751 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22752 }
22753 arg1 = static_cast< wxEventType >(val1);
22754 }
22755 {
22756 PyThreadState* __tstate = wxPyBeginAllowThreads();
22757 result = (wxMouseEvent *)new wxMouseEvent(arg1);
22758 wxPyEndAllowThreads(__tstate);
22759 if (PyErr_Occurred()) SWIG_fail;
22760 }
22761 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_NEW | 0 );
22762 return resultobj;
22763 fail:
22764 return NULL;
22765 }
22766
22767
22768 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22769 PyObject *resultobj = 0;
22770 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22771 bool result;
22772 void *argp1 = 0 ;
22773 int res1 = 0 ;
22774 PyObject *swig_obj[1] ;
22775
22776 if (!args) SWIG_fail;
22777 swig_obj[0] = args;
22778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22779 if (!SWIG_IsOK(res1)) {
22780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22781 }
22782 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22783 {
22784 PyThreadState* __tstate = wxPyBeginAllowThreads();
22785 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
22786 wxPyEndAllowThreads(__tstate);
22787 if (PyErr_Occurred()) SWIG_fail;
22788 }
22789 {
22790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22791 }
22792 return resultobj;
22793 fail:
22794 return NULL;
22795 }
22796
22797
22798 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22799 PyObject *resultobj = 0;
22800 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22801 int arg2 = (int) wxMOUSE_BTN_ANY ;
22802 bool result;
22803 void *argp1 = 0 ;
22804 int res1 = 0 ;
22805 int val2 ;
22806 int ecode2 = 0 ;
22807 PyObject * obj0 = 0 ;
22808 PyObject * obj1 = 0 ;
22809 char * kwnames[] = {
22810 (char *) "self",(char *) "but", NULL
22811 };
22812
22813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
22814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22815 if (!SWIG_IsOK(res1)) {
22816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22817 }
22818 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22819 if (obj1) {
22820 ecode2 = SWIG_AsVal_int(obj1, &val2);
22821 if (!SWIG_IsOK(ecode2)) {
22822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
22823 }
22824 arg2 = static_cast< int >(val2);
22825 }
22826 {
22827 PyThreadState* __tstate = wxPyBeginAllowThreads();
22828 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
22829 wxPyEndAllowThreads(__tstate);
22830 if (PyErr_Occurred()) SWIG_fail;
22831 }
22832 {
22833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22834 }
22835 return resultobj;
22836 fail:
22837 return NULL;
22838 }
22839
22840
22841 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22842 PyObject *resultobj = 0;
22843 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22844 int arg2 = (int) wxMOUSE_BTN_ANY ;
22845 bool result;
22846 void *argp1 = 0 ;
22847 int res1 = 0 ;
22848 int val2 ;
22849 int ecode2 = 0 ;
22850 PyObject * obj0 = 0 ;
22851 PyObject * obj1 = 0 ;
22852 char * kwnames[] = {
22853 (char *) "self",(char *) "but", NULL
22854 };
22855
22856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
22857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22858 if (!SWIG_IsOK(res1)) {
22859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22860 }
22861 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22862 if (obj1) {
22863 ecode2 = SWIG_AsVal_int(obj1, &val2);
22864 if (!SWIG_IsOK(ecode2)) {
22865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
22866 }
22867 arg2 = static_cast< int >(val2);
22868 }
22869 {
22870 PyThreadState* __tstate = wxPyBeginAllowThreads();
22871 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
22872 wxPyEndAllowThreads(__tstate);
22873 if (PyErr_Occurred()) SWIG_fail;
22874 }
22875 {
22876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22877 }
22878 return resultobj;
22879 fail:
22880 return NULL;
22881 }
22882
22883
22884 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22885 PyObject *resultobj = 0;
22886 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22887 int arg2 = (int) wxMOUSE_BTN_ANY ;
22888 bool result;
22889 void *argp1 = 0 ;
22890 int res1 = 0 ;
22891 int val2 ;
22892 int ecode2 = 0 ;
22893 PyObject * obj0 = 0 ;
22894 PyObject * obj1 = 0 ;
22895 char * kwnames[] = {
22896 (char *) "self",(char *) "but", NULL
22897 };
22898
22899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
22900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22901 if (!SWIG_IsOK(res1)) {
22902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22903 }
22904 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22905 if (obj1) {
22906 ecode2 = SWIG_AsVal_int(obj1, &val2);
22907 if (!SWIG_IsOK(ecode2)) {
22908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
22909 }
22910 arg2 = static_cast< int >(val2);
22911 }
22912 {
22913 PyThreadState* __tstate = wxPyBeginAllowThreads();
22914 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
22915 wxPyEndAllowThreads(__tstate);
22916 if (PyErr_Occurred()) SWIG_fail;
22917 }
22918 {
22919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22920 }
22921 return resultobj;
22922 fail:
22923 return NULL;
22924 }
22925
22926
22927 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22928 PyObject *resultobj = 0;
22929 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22930 int arg2 ;
22931 bool result;
22932 void *argp1 = 0 ;
22933 int res1 = 0 ;
22934 int val2 ;
22935 int ecode2 = 0 ;
22936 PyObject * obj0 = 0 ;
22937 PyObject * obj1 = 0 ;
22938 char * kwnames[] = {
22939 (char *) "self",(char *) "button", NULL
22940 };
22941
22942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
22943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22944 if (!SWIG_IsOK(res1)) {
22945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22946 }
22947 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22948 ecode2 = SWIG_AsVal_int(obj1, &val2);
22949 if (!SWIG_IsOK(ecode2)) {
22950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
22951 }
22952 arg2 = static_cast< int >(val2);
22953 {
22954 PyThreadState* __tstate = wxPyBeginAllowThreads();
22955 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
22956 wxPyEndAllowThreads(__tstate);
22957 if (PyErr_Occurred()) SWIG_fail;
22958 }
22959 {
22960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22961 }
22962 return resultobj;
22963 fail:
22964 return NULL;
22965 }
22966
22967
22968 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22969 PyObject *resultobj = 0;
22970 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22971 int arg2 ;
22972 bool result;
22973 void *argp1 = 0 ;
22974 int res1 = 0 ;
22975 int val2 ;
22976 int ecode2 = 0 ;
22977 PyObject * obj0 = 0 ;
22978 PyObject * obj1 = 0 ;
22979 char * kwnames[] = {
22980 (char *) "self",(char *) "but", NULL
22981 };
22982
22983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
22984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22985 if (!SWIG_IsOK(res1)) {
22986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22987 }
22988 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22989 ecode2 = SWIG_AsVal_int(obj1, &val2);
22990 if (!SWIG_IsOK(ecode2)) {
22991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
22992 }
22993 arg2 = static_cast< int >(val2);
22994 {
22995 PyThreadState* __tstate = wxPyBeginAllowThreads();
22996 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
22997 wxPyEndAllowThreads(__tstate);
22998 if (PyErr_Occurred()) SWIG_fail;
22999 }
23000 {
23001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23002 }
23003 return resultobj;
23004 fail:
23005 return NULL;
23006 }
23007
23008
23009 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23010 PyObject *resultobj = 0;
23011 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23012 int result;
23013 void *argp1 = 0 ;
23014 int res1 = 0 ;
23015 PyObject *swig_obj[1] ;
23016
23017 if (!args) SWIG_fail;
23018 swig_obj[0] = args;
23019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23020 if (!SWIG_IsOK(res1)) {
23021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23022 }
23023 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23024 {
23025 PyThreadState* __tstate = wxPyBeginAllowThreads();
23026 result = (int)((wxMouseEvent const *)arg1)->GetButton();
23027 wxPyEndAllowThreads(__tstate);
23028 if (PyErr_Occurred()) SWIG_fail;
23029 }
23030 resultobj = SWIG_From_int(static_cast< int >(result));
23031 return resultobj;
23032 fail:
23033 return NULL;
23034 }
23035
23036
23037 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23038 PyObject *resultobj = 0;
23039 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23040 bool result;
23041 void *argp1 = 0 ;
23042 int res1 = 0 ;
23043 PyObject *swig_obj[1] ;
23044
23045 if (!args) SWIG_fail;
23046 swig_obj[0] = args;
23047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23048 if (!SWIG_IsOK(res1)) {
23049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23050 }
23051 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23052 {
23053 PyThreadState* __tstate = wxPyBeginAllowThreads();
23054 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
23055 wxPyEndAllowThreads(__tstate);
23056 if (PyErr_Occurred()) SWIG_fail;
23057 }
23058 {
23059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23060 }
23061 return resultobj;
23062 fail:
23063 return NULL;
23064 }
23065
23066
23067 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23068 PyObject *resultobj = 0;
23069 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23070 bool result;
23071 void *argp1 = 0 ;
23072 int res1 = 0 ;
23073 PyObject *swig_obj[1] ;
23074
23075 if (!args) SWIG_fail;
23076 swig_obj[0] = args;
23077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23078 if (!SWIG_IsOK(res1)) {
23079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23080 }
23081 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23082 {
23083 PyThreadState* __tstate = wxPyBeginAllowThreads();
23084 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
23085 wxPyEndAllowThreads(__tstate);
23086 if (PyErr_Occurred()) SWIG_fail;
23087 }
23088 {
23089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23090 }
23091 return resultobj;
23092 fail:
23093 return NULL;
23094 }
23095
23096
23097 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23098 PyObject *resultobj = 0;
23099 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23100 bool result;
23101 void *argp1 = 0 ;
23102 int res1 = 0 ;
23103 PyObject *swig_obj[1] ;
23104
23105 if (!args) SWIG_fail;
23106 swig_obj[0] = args;
23107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23108 if (!SWIG_IsOK(res1)) {
23109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23110 }
23111 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23112 {
23113 PyThreadState* __tstate = wxPyBeginAllowThreads();
23114 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
23115 wxPyEndAllowThreads(__tstate);
23116 if (PyErr_Occurred()) SWIG_fail;
23117 }
23118 {
23119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23120 }
23121 return resultobj;
23122 fail:
23123 return NULL;
23124 }
23125
23126
23127 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23128 PyObject *resultobj = 0;
23129 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23130 bool result;
23131 void *argp1 = 0 ;
23132 int res1 = 0 ;
23133 PyObject *swig_obj[1] ;
23134
23135 if (!args) SWIG_fail;
23136 swig_obj[0] = args;
23137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23138 if (!SWIG_IsOK(res1)) {
23139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23140 }
23141 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23142 {
23143 PyThreadState* __tstate = wxPyBeginAllowThreads();
23144 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
23145 wxPyEndAllowThreads(__tstate);
23146 if (PyErr_Occurred()) SWIG_fail;
23147 }
23148 {
23149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23150 }
23151 return resultobj;
23152 fail:
23153 return NULL;
23154 }
23155
23156
23157 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23158 PyObject *resultobj = 0;
23159 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23160 bool result;
23161 void *argp1 = 0 ;
23162 int res1 = 0 ;
23163 PyObject *swig_obj[1] ;
23164
23165 if (!args) SWIG_fail;
23166 swig_obj[0] = args;
23167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23168 if (!SWIG_IsOK(res1)) {
23169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23170 }
23171 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23172 {
23173 PyThreadState* __tstate = wxPyBeginAllowThreads();
23174 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
23175 wxPyEndAllowThreads(__tstate);
23176 if (PyErr_Occurred()) SWIG_fail;
23177 }
23178 {
23179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23180 }
23181 return resultobj;
23182 fail:
23183 return NULL;
23184 }
23185
23186
23187 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23188 PyObject *resultobj = 0;
23189 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23190 bool result;
23191 void *argp1 = 0 ;
23192 int res1 = 0 ;
23193 PyObject *swig_obj[1] ;
23194
23195 if (!args) SWIG_fail;
23196 swig_obj[0] = args;
23197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23198 if (!SWIG_IsOK(res1)) {
23199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23200 }
23201 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23202 {
23203 PyThreadState* __tstate = wxPyBeginAllowThreads();
23204 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
23205 wxPyEndAllowThreads(__tstate);
23206 if (PyErr_Occurred()) SWIG_fail;
23207 }
23208 {
23209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23210 }
23211 return resultobj;
23212 fail:
23213 return NULL;
23214 }
23215
23216
23217 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23218 PyObject *resultobj = 0;
23219 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23220 bool result;
23221 void *argp1 = 0 ;
23222 int res1 = 0 ;
23223 PyObject *swig_obj[1] ;
23224
23225 if (!args) SWIG_fail;
23226 swig_obj[0] = args;
23227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23228 if (!SWIG_IsOK(res1)) {
23229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23230 }
23231 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23232 {
23233 PyThreadState* __tstate = wxPyBeginAllowThreads();
23234 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
23235 wxPyEndAllowThreads(__tstate);
23236 if (PyErr_Occurred()) SWIG_fail;
23237 }
23238 {
23239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23240 }
23241 return resultobj;
23242 fail:
23243 return NULL;
23244 }
23245
23246
23247 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23248 PyObject *resultobj = 0;
23249 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23250 bool result;
23251 void *argp1 = 0 ;
23252 int res1 = 0 ;
23253 PyObject *swig_obj[1] ;
23254
23255 if (!args) SWIG_fail;
23256 swig_obj[0] = args;
23257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23258 if (!SWIG_IsOK(res1)) {
23259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23260 }
23261 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23262 {
23263 PyThreadState* __tstate = wxPyBeginAllowThreads();
23264 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
23265 wxPyEndAllowThreads(__tstate);
23266 if (PyErr_Occurred()) SWIG_fail;
23267 }
23268 {
23269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23270 }
23271 return resultobj;
23272 fail:
23273 return NULL;
23274 }
23275
23276
23277 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23278 PyObject *resultobj = 0;
23279 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23280 bool result;
23281 void *argp1 = 0 ;
23282 int res1 = 0 ;
23283 PyObject *swig_obj[1] ;
23284
23285 if (!args) SWIG_fail;
23286 swig_obj[0] = args;
23287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23288 if (!SWIG_IsOK(res1)) {
23289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23290 }
23291 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23292 {
23293 PyThreadState* __tstate = wxPyBeginAllowThreads();
23294 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
23295 wxPyEndAllowThreads(__tstate);
23296 if (PyErr_Occurred()) SWIG_fail;
23297 }
23298 {
23299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23300 }
23301 return resultobj;
23302 fail:
23303 return NULL;
23304 }
23305
23306
23307 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23308 PyObject *resultobj = 0;
23309 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23310 bool result;
23311 void *argp1 = 0 ;
23312 int res1 = 0 ;
23313 PyObject *swig_obj[1] ;
23314
23315 if (!args) SWIG_fail;
23316 swig_obj[0] = args;
23317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23318 if (!SWIG_IsOK(res1)) {
23319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23320 }
23321 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23322 {
23323 PyThreadState* __tstate = wxPyBeginAllowThreads();
23324 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
23325 wxPyEndAllowThreads(__tstate);
23326 if (PyErr_Occurred()) SWIG_fail;
23327 }
23328 {
23329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23330 }
23331 return resultobj;
23332 fail:
23333 return NULL;
23334 }
23335
23336
23337 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23338 PyObject *resultobj = 0;
23339 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23340 bool result;
23341 void *argp1 = 0 ;
23342 int res1 = 0 ;
23343 PyObject *swig_obj[1] ;
23344
23345 if (!args) SWIG_fail;
23346 swig_obj[0] = args;
23347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23348 if (!SWIG_IsOK(res1)) {
23349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23350 }
23351 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23352 {
23353 PyThreadState* __tstate = wxPyBeginAllowThreads();
23354 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
23355 wxPyEndAllowThreads(__tstate);
23356 if (PyErr_Occurred()) SWIG_fail;
23357 }
23358 {
23359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23360 }
23361 return resultobj;
23362 fail:
23363 return NULL;
23364 }
23365
23366
23367 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23368 PyObject *resultobj = 0;
23369 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23370 bool result;
23371 void *argp1 = 0 ;
23372 int res1 = 0 ;
23373 PyObject *swig_obj[1] ;
23374
23375 if (!args) SWIG_fail;
23376 swig_obj[0] = args;
23377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23378 if (!SWIG_IsOK(res1)) {
23379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23380 }
23381 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23382 {
23383 PyThreadState* __tstate = wxPyBeginAllowThreads();
23384 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
23385 wxPyEndAllowThreads(__tstate);
23386 if (PyErr_Occurred()) SWIG_fail;
23387 }
23388 {
23389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23390 }
23391 return resultobj;
23392 fail:
23393 return NULL;
23394 }
23395
23396
23397 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23398 PyObject *resultobj = 0;
23399 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23400 bool result;
23401 void *argp1 = 0 ;
23402 int res1 = 0 ;
23403 PyObject *swig_obj[1] ;
23404
23405 if (!args) SWIG_fail;
23406 swig_obj[0] = args;
23407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23408 if (!SWIG_IsOK(res1)) {
23409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23410 }
23411 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23412 {
23413 PyThreadState* __tstate = wxPyBeginAllowThreads();
23414 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
23415 wxPyEndAllowThreads(__tstate);
23416 if (PyErr_Occurred()) SWIG_fail;
23417 }
23418 {
23419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23420 }
23421 return resultobj;
23422 fail:
23423 return NULL;
23424 }
23425
23426
23427 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23428 PyObject *resultobj = 0;
23429 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23430 bool result;
23431 void *argp1 = 0 ;
23432 int res1 = 0 ;
23433 PyObject *swig_obj[1] ;
23434
23435 if (!args) SWIG_fail;
23436 swig_obj[0] = args;
23437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23438 if (!SWIG_IsOK(res1)) {
23439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23440 }
23441 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23442 {
23443 PyThreadState* __tstate = wxPyBeginAllowThreads();
23444 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
23445 wxPyEndAllowThreads(__tstate);
23446 if (PyErr_Occurred()) SWIG_fail;
23447 }
23448 {
23449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23450 }
23451 return resultobj;
23452 fail:
23453 return NULL;
23454 }
23455
23456
23457 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23458 PyObject *resultobj = 0;
23459 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23460 bool result;
23461 void *argp1 = 0 ;
23462 int res1 = 0 ;
23463 PyObject *swig_obj[1] ;
23464
23465 if (!args) SWIG_fail;
23466 swig_obj[0] = args;
23467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23468 if (!SWIG_IsOK(res1)) {
23469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23470 }
23471 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23472 {
23473 PyThreadState* __tstate = wxPyBeginAllowThreads();
23474 result = (bool)(arg1)->LeftIsDown();
23475 wxPyEndAllowThreads(__tstate);
23476 if (PyErr_Occurred()) SWIG_fail;
23477 }
23478 {
23479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23480 }
23481 return resultobj;
23482 fail:
23483 return NULL;
23484 }
23485
23486
23487 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23488 PyObject *resultobj = 0;
23489 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23490 bool result;
23491 void *argp1 = 0 ;
23492 int res1 = 0 ;
23493 PyObject *swig_obj[1] ;
23494
23495 if (!args) SWIG_fail;
23496 swig_obj[0] = args;
23497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23498 if (!SWIG_IsOK(res1)) {
23499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23500 }
23501 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23502 {
23503 PyThreadState* __tstate = wxPyBeginAllowThreads();
23504 result = (bool)(arg1)->MiddleIsDown();
23505 wxPyEndAllowThreads(__tstate);
23506 if (PyErr_Occurred()) SWIG_fail;
23507 }
23508 {
23509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23510 }
23511 return resultobj;
23512 fail:
23513 return NULL;
23514 }
23515
23516
23517 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23518 PyObject *resultobj = 0;
23519 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23520 bool result;
23521 void *argp1 = 0 ;
23522 int res1 = 0 ;
23523 PyObject *swig_obj[1] ;
23524
23525 if (!args) SWIG_fail;
23526 swig_obj[0] = args;
23527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23528 if (!SWIG_IsOK(res1)) {
23529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23530 }
23531 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23532 {
23533 PyThreadState* __tstate = wxPyBeginAllowThreads();
23534 result = (bool)(arg1)->RightIsDown();
23535 wxPyEndAllowThreads(__tstate);
23536 if (PyErr_Occurred()) SWIG_fail;
23537 }
23538 {
23539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23540 }
23541 return resultobj;
23542 fail:
23543 return NULL;
23544 }
23545
23546
23547 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23548 PyObject *resultobj = 0;
23549 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23550 bool result;
23551 void *argp1 = 0 ;
23552 int res1 = 0 ;
23553 PyObject *swig_obj[1] ;
23554
23555 if (!args) SWIG_fail;
23556 swig_obj[0] = args;
23557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23558 if (!SWIG_IsOK(res1)) {
23559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23560 }
23561 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23562 {
23563 PyThreadState* __tstate = wxPyBeginAllowThreads();
23564 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
23565 wxPyEndAllowThreads(__tstate);
23566 if (PyErr_Occurred()) SWIG_fail;
23567 }
23568 {
23569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23570 }
23571 return resultobj;
23572 fail:
23573 return NULL;
23574 }
23575
23576
23577 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23578 PyObject *resultobj = 0;
23579 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23580 bool result;
23581 void *argp1 = 0 ;
23582 int res1 = 0 ;
23583 PyObject *swig_obj[1] ;
23584
23585 if (!args) SWIG_fail;
23586 swig_obj[0] = args;
23587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23588 if (!SWIG_IsOK(res1)) {
23589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23590 }
23591 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23592 {
23593 PyThreadState* __tstate = wxPyBeginAllowThreads();
23594 result = (bool)((wxMouseEvent const *)arg1)->Moving();
23595 wxPyEndAllowThreads(__tstate);
23596 if (PyErr_Occurred()) SWIG_fail;
23597 }
23598 {
23599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23600 }
23601 return resultobj;
23602 fail:
23603 return NULL;
23604 }
23605
23606
23607 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23608 PyObject *resultobj = 0;
23609 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23610 bool result;
23611 void *argp1 = 0 ;
23612 int res1 = 0 ;
23613 PyObject *swig_obj[1] ;
23614
23615 if (!args) SWIG_fail;
23616 swig_obj[0] = args;
23617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23618 if (!SWIG_IsOK(res1)) {
23619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23620 }
23621 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23622 {
23623 PyThreadState* __tstate = wxPyBeginAllowThreads();
23624 result = (bool)((wxMouseEvent const *)arg1)->Entering();
23625 wxPyEndAllowThreads(__tstate);
23626 if (PyErr_Occurred()) SWIG_fail;
23627 }
23628 {
23629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23630 }
23631 return resultobj;
23632 fail:
23633 return NULL;
23634 }
23635
23636
23637 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23638 PyObject *resultobj = 0;
23639 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23640 bool result;
23641 void *argp1 = 0 ;
23642 int res1 = 0 ;
23643 PyObject *swig_obj[1] ;
23644
23645 if (!args) SWIG_fail;
23646 swig_obj[0] = args;
23647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23648 if (!SWIG_IsOK(res1)) {
23649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23650 }
23651 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23652 {
23653 PyThreadState* __tstate = wxPyBeginAllowThreads();
23654 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
23655 wxPyEndAllowThreads(__tstate);
23656 if (PyErr_Occurred()) SWIG_fail;
23657 }
23658 {
23659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23660 }
23661 return resultobj;
23662 fail:
23663 return NULL;
23664 }
23665
23666
23667 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23668 PyObject *resultobj = 0;
23669 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23670 wxPoint result;
23671 void *argp1 = 0 ;
23672 int res1 = 0 ;
23673 PyObject *swig_obj[1] ;
23674
23675 if (!args) SWIG_fail;
23676 swig_obj[0] = args;
23677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23678 if (!SWIG_IsOK(res1)) {
23679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23680 }
23681 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23682 {
23683 PyThreadState* __tstate = wxPyBeginAllowThreads();
23684 result = (arg1)->GetPosition();
23685 wxPyEndAllowThreads(__tstate);
23686 if (PyErr_Occurred()) SWIG_fail;
23687 }
23688 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23689 return resultobj;
23690 fail:
23691 return NULL;
23692 }
23693
23694
23695 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23696 PyObject *resultobj = 0;
23697 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23698 long *arg2 = (long *) 0 ;
23699 long *arg3 = (long *) 0 ;
23700 void *argp1 = 0 ;
23701 int res1 = 0 ;
23702 long temp2 ;
23703 int res2 = SWIG_TMPOBJ ;
23704 long temp3 ;
23705 int res3 = SWIG_TMPOBJ ;
23706 PyObject *swig_obj[1] ;
23707
23708 arg2 = &temp2;
23709 arg3 = &temp3;
23710 if (!args) SWIG_fail;
23711 swig_obj[0] = args;
23712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23713 if (!SWIG_IsOK(res1)) {
23714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23715 }
23716 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23717 {
23718 PyThreadState* __tstate = wxPyBeginAllowThreads();
23719 (arg1)->GetPosition(arg2,arg3);
23720 wxPyEndAllowThreads(__tstate);
23721 if (PyErr_Occurred()) SWIG_fail;
23722 }
23723 resultobj = SWIG_Py_Void();
23724 if (SWIG_IsTmpObj(res2)) {
23725 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
23726 } else {
23727 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23728 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
23729 }
23730 if (SWIG_IsTmpObj(res3)) {
23731 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
23732 } else {
23733 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23734 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
23735 }
23736 return resultobj;
23737 fail:
23738 return NULL;
23739 }
23740
23741
23742 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23743 PyObject *resultobj = 0;
23744 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23745 wxDC *arg2 = 0 ;
23746 wxPoint result;
23747 void *argp1 = 0 ;
23748 int res1 = 0 ;
23749 void *argp2 = 0 ;
23750 int res2 = 0 ;
23751 PyObject * obj0 = 0 ;
23752 PyObject * obj1 = 0 ;
23753 char * kwnames[] = {
23754 (char *) "self",(char *) "dc", NULL
23755 };
23756
23757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23759 if (!SWIG_IsOK(res1)) {
23760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23761 }
23762 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23763 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
23764 if (!SWIG_IsOK(res2)) {
23765 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23766 }
23767 if (!argp2) {
23768 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23769 }
23770 arg2 = reinterpret_cast< wxDC * >(argp2);
23771 {
23772 PyThreadState* __tstate = wxPyBeginAllowThreads();
23773 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
23774 wxPyEndAllowThreads(__tstate);
23775 if (PyErr_Occurred()) SWIG_fail;
23776 }
23777 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23778 return resultobj;
23779 fail:
23780 return NULL;
23781 }
23782
23783
23784 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23785 PyObject *resultobj = 0;
23786 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23787 int result;
23788 void *argp1 = 0 ;
23789 int res1 = 0 ;
23790 PyObject *swig_obj[1] ;
23791
23792 if (!args) SWIG_fail;
23793 swig_obj[0] = args;
23794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23795 if (!SWIG_IsOK(res1)) {
23796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23797 }
23798 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23799 {
23800 PyThreadState* __tstate = wxPyBeginAllowThreads();
23801 result = (int)((wxMouseEvent const *)arg1)->GetX();
23802 wxPyEndAllowThreads(__tstate);
23803 if (PyErr_Occurred()) SWIG_fail;
23804 }
23805 resultobj = SWIG_From_int(static_cast< int >(result));
23806 return resultobj;
23807 fail:
23808 return NULL;
23809 }
23810
23811
23812 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23813 PyObject *resultobj = 0;
23814 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23815 int result;
23816 void *argp1 = 0 ;
23817 int res1 = 0 ;
23818 PyObject *swig_obj[1] ;
23819
23820 if (!args) SWIG_fail;
23821 swig_obj[0] = args;
23822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23823 if (!SWIG_IsOK(res1)) {
23824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23825 }
23826 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23827 {
23828 PyThreadState* __tstate = wxPyBeginAllowThreads();
23829 result = (int)((wxMouseEvent const *)arg1)->GetY();
23830 wxPyEndAllowThreads(__tstate);
23831 if (PyErr_Occurred()) SWIG_fail;
23832 }
23833 resultobj = SWIG_From_int(static_cast< int >(result));
23834 return resultobj;
23835 fail:
23836 return NULL;
23837 }
23838
23839
23840 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23841 PyObject *resultobj = 0;
23842 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23843 int result;
23844 void *argp1 = 0 ;
23845 int res1 = 0 ;
23846 PyObject *swig_obj[1] ;
23847
23848 if (!args) SWIG_fail;
23849 swig_obj[0] = args;
23850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23851 if (!SWIG_IsOK(res1)) {
23852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23853 }
23854 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23855 {
23856 PyThreadState* __tstate = wxPyBeginAllowThreads();
23857 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
23858 wxPyEndAllowThreads(__tstate);
23859 if (PyErr_Occurred()) SWIG_fail;
23860 }
23861 resultobj = SWIG_From_int(static_cast< int >(result));
23862 return resultobj;
23863 fail:
23864 return NULL;
23865 }
23866
23867
23868 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23869 PyObject *resultobj = 0;
23870 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23871 int result;
23872 void *argp1 = 0 ;
23873 int res1 = 0 ;
23874 PyObject *swig_obj[1] ;
23875
23876 if (!args) SWIG_fail;
23877 swig_obj[0] = args;
23878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23879 if (!SWIG_IsOK(res1)) {
23880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23881 }
23882 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23883 {
23884 PyThreadState* __tstate = wxPyBeginAllowThreads();
23885 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
23886 wxPyEndAllowThreads(__tstate);
23887 if (PyErr_Occurred()) SWIG_fail;
23888 }
23889 resultobj = SWIG_From_int(static_cast< int >(result));
23890 return resultobj;
23891 fail:
23892 return NULL;
23893 }
23894
23895
23896 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23897 PyObject *resultobj = 0;
23898 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23899 int result;
23900 void *argp1 = 0 ;
23901 int res1 = 0 ;
23902 PyObject *swig_obj[1] ;
23903
23904 if (!args) SWIG_fail;
23905 swig_obj[0] = args;
23906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23907 if (!SWIG_IsOK(res1)) {
23908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23909 }
23910 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23911 {
23912 PyThreadState* __tstate = wxPyBeginAllowThreads();
23913 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
23914 wxPyEndAllowThreads(__tstate);
23915 if (PyErr_Occurred()) SWIG_fail;
23916 }
23917 resultobj = SWIG_From_int(static_cast< int >(result));
23918 return resultobj;
23919 fail:
23920 return NULL;
23921 }
23922
23923
23924 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23925 PyObject *resultobj = 0;
23926 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23927 bool result;
23928 void *argp1 = 0 ;
23929 int res1 = 0 ;
23930 PyObject *swig_obj[1] ;
23931
23932 if (!args) SWIG_fail;
23933 swig_obj[0] = args;
23934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23935 if (!SWIG_IsOK(res1)) {
23936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23937 }
23938 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23939 {
23940 PyThreadState* __tstate = wxPyBeginAllowThreads();
23941 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
23942 wxPyEndAllowThreads(__tstate);
23943 if (PyErr_Occurred()) SWIG_fail;
23944 }
23945 {
23946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23947 }
23948 return resultobj;
23949 fail:
23950 return NULL;
23951 }
23952
23953
23954 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23955 PyObject *resultobj = 0;
23956 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23957 int arg2 ;
23958 void *argp1 = 0 ;
23959 int res1 = 0 ;
23960 int val2 ;
23961 int ecode2 = 0 ;
23962 PyObject *swig_obj[2] ;
23963
23964 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
23965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23966 if (!SWIG_IsOK(res1)) {
23967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23968 }
23969 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23970 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23971 if (!SWIG_IsOK(ecode2)) {
23972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
23973 }
23974 arg2 = static_cast< int >(val2);
23975 if (arg1) (arg1)->m_x = arg2;
23976
23977 resultobj = SWIG_Py_Void();
23978 return resultobj;
23979 fail:
23980 return NULL;
23981 }
23982
23983
23984 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23985 PyObject *resultobj = 0;
23986 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23987 int result;
23988 void *argp1 = 0 ;
23989 int res1 = 0 ;
23990 PyObject *swig_obj[1] ;
23991
23992 if (!args) SWIG_fail;
23993 swig_obj[0] = args;
23994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23995 if (!SWIG_IsOK(res1)) {
23996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23997 }
23998 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23999 result = (int) ((arg1)->m_x);
24000 resultobj = SWIG_From_int(static_cast< int >(result));
24001 return resultobj;
24002 fail:
24003 return NULL;
24004 }
24005
24006
24007 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24008 PyObject *resultobj = 0;
24009 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24010 int arg2 ;
24011 void *argp1 = 0 ;
24012 int res1 = 0 ;
24013 int val2 ;
24014 int ecode2 = 0 ;
24015 PyObject *swig_obj[2] ;
24016
24017 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
24018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24019 if (!SWIG_IsOK(res1)) {
24020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24021 }
24022 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24023 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24024 if (!SWIG_IsOK(ecode2)) {
24025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
24026 }
24027 arg2 = static_cast< int >(val2);
24028 if (arg1) (arg1)->m_y = arg2;
24029
24030 resultobj = SWIG_Py_Void();
24031 return resultobj;
24032 fail:
24033 return NULL;
24034 }
24035
24036
24037 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24038 PyObject *resultobj = 0;
24039 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24040 int result;
24041 void *argp1 = 0 ;
24042 int res1 = 0 ;
24043 PyObject *swig_obj[1] ;
24044
24045 if (!args) SWIG_fail;
24046 swig_obj[0] = args;
24047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24048 if (!SWIG_IsOK(res1)) {
24049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24050 }
24051 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24052 result = (int) ((arg1)->m_y);
24053 resultobj = SWIG_From_int(static_cast< int >(result));
24054 return resultobj;
24055 fail:
24056 return NULL;
24057 }
24058
24059
24060 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24061 PyObject *resultobj = 0;
24062 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24063 bool arg2 ;
24064 void *argp1 = 0 ;
24065 int res1 = 0 ;
24066 bool val2 ;
24067 int ecode2 = 0 ;
24068 PyObject *swig_obj[2] ;
24069
24070 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
24071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24072 if (!SWIG_IsOK(res1)) {
24073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24074 }
24075 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24076 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24077 if (!SWIG_IsOK(ecode2)) {
24078 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
24079 }
24080 arg2 = static_cast< bool >(val2);
24081 if (arg1) (arg1)->m_leftDown = arg2;
24082
24083 resultobj = SWIG_Py_Void();
24084 return resultobj;
24085 fail:
24086 return NULL;
24087 }
24088
24089
24090 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24091 PyObject *resultobj = 0;
24092 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24093 bool result;
24094 void *argp1 = 0 ;
24095 int res1 = 0 ;
24096 PyObject *swig_obj[1] ;
24097
24098 if (!args) SWIG_fail;
24099 swig_obj[0] = args;
24100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24101 if (!SWIG_IsOK(res1)) {
24102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24103 }
24104 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24105 result = (bool) ((arg1)->m_leftDown);
24106 {
24107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24108 }
24109 return resultobj;
24110 fail:
24111 return NULL;
24112 }
24113
24114
24115 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24116 PyObject *resultobj = 0;
24117 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24118 bool arg2 ;
24119 void *argp1 = 0 ;
24120 int res1 = 0 ;
24121 bool val2 ;
24122 int ecode2 = 0 ;
24123 PyObject *swig_obj[2] ;
24124
24125 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
24126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24127 if (!SWIG_IsOK(res1)) {
24128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24129 }
24130 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24131 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24132 if (!SWIG_IsOK(ecode2)) {
24133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
24134 }
24135 arg2 = static_cast< bool >(val2);
24136 if (arg1) (arg1)->m_middleDown = arg2;
24137
24138 resultobj = SWIG_Py_Void();
24139 return resultobj;
24140 fail:
24141 return NULL;
24142 }
24143
24144
24145 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24146 PyObject *resultobj = 0;
24147 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24148 bool result;
24149 void *argp1 = 0 ;
24150 int res1 = 0 ;
24151 PyObject *swig_obj[1] ;
24152
24153 if (!args) SWIG_fail;
24154 swig_obj[0] = args;
24155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24156 if (!SWIG_IsOK(res1)) {
24157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24158 }
24159 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24160 result = (bool) ((arg1)->m_middleDown);
24161 {
24162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24163 }
24164 return resultobj;
24165 fail:
24166 return NULL;
24167 }
24168
24169
24170 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24171 PyObject *resultobj = 0;
24172 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24173 bool arg2 ;
24174 void *argp1 = 0 ;
24175 int res1 = 0 ;
24176 bool val2 ;
24177 int ecode2 = 0 ;
24178 PyObject *swig_obj[2] ;
24179
24180 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
24181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24182 if (!SWIG_IsOK(res1)) {
24183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24184 }
24185 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24186 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24187 if (!SWIG_IsOK(ecode2)) {
24188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
24189 }
24190 arg2 = static_cast< bool >(val2);
24191 if (arg1) (arg1)->m_rightDown = arg2;
24192
24193 resultobj = SWIG_Py_Void();
24194 return resultobj;
24195 fail:
24196 return NULL;
24197 }
24198
24199
24200 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24201 PyObject *resultobj = 0;
24202 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24203 bool result;
24204 void *argp1 = 0 ;
24205 int res1 = 0 ;
24206 PyObject *swig_obj[1] ;
24207
24208 if (!args) SWIG_fail;
24209 swig_obj[0] = args;
24210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24211 if (!SWIG_IsOK(res1)) {
24212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24213 }
24214 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24215 result = (bool) ((arg1)->m_rightDown);
24216 {
24217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24218 }
24219 return resultobj;
24220 fail:
24221 return NULL;
24222 }
24223
24224
24225 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24226 PyObject *resultobj = 0;
24227 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24228 bool arg2 ;
24229 void *argp1 = 0 ;
24230 int res1 = 0 ;
24231 bool val2 ;
24232 int ecode2 = 0 ;
24233 PyObject *swig_obj[2] ;
24234
24235 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
24236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24237 if (!SWIG_IsOK(res1)) {
24238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24239 }
24240 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24241 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24242 if (!SWIG_IsOK(ecode2)) {
24243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
24244 }
24245 arg2 = static_cast< bool >(val2);
24246 if (arg1) (arg1)->m_controlDown = arg2;
24247
24248 resultobj = SWIG_Py_Void();
24249 return resultobj;
24250 fail:
24251 return NULL;
24252 }
24253
24254
24255 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24256 PyObject *resultobj = 0;
24257 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24258 bool result;
24259 void *argp1 = 0 ;
24260 int res1 = 0 ;
24261 PyObject *swig_obj[1] ;
24262
24263 if (!args) SWIG_fail;
24264 swig_obj[0] = args;
24265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24266 if (!SWIG_IsOK(res1)) {
24267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24268 }
24269 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24270 result = (bool) ((arg1)->m_controlDown);
24271 {
24272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24273 }
24274 return resultobj;
24275 fail:
24276 return NULL;
24277 }
24278
24279
24280 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24281 PyObject *resultobj = 0;
24282 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24283 bool arg2 ;
24284 void *argp1 = 0 ;
24285 int res1 = 0 ;
24286 bool val2 ;
24287 int ecode2 = 0 ;
24288 PyObject *swig_obj[2] ;
24289
24290 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
24291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24292 if (!SWIG_IsOK(res1)) {
24293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24294 }
24295 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24296 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24297 if (!SWIG_IsOK(ecode2)) {
24298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
24299 }
24300 arg2 = static_cast< bool >(val2);
24301 if (arg1) (arg1)->m_shiftDown = arg2;
24302
24303 resultobj = SWIG_Py_Void();
24304 return resultobj;
24305 fail:
24306 return NULL;
24307 }
24308
24309
24310 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24311 PyObject *resultobj = 0;
24312 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24313 bool result;
24314 void *argp1 = 0 ;
24315 int res1 = 0 ;
24316 PyObject *swig_obj[1] ;
24317
24318 if (!args) SWIG_fail;
24319 swig_obj[0] = args;
24320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24321 if (!SWIG_IsOK(res1)) {
24322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24323 }
24324 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24325 result = (bool) ((arg1)->m_shiftDown);
24326 {
24327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24328 }
24329 return resultobj;
24330 fail:
24331 return NULL;
24332 }
24333
24334
24335 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24336 PyObject *resultobj = 0;
24337 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24338 bool arg2 ;
24339 void *argp1 = 0 ;
24340 int res1 = 0 ;
24341 bool val2 ;
24342 int ecode2 = 0 ;
24343 PyObject *swig_obj[2] ;
24344
24345 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
24346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24347 if (!SWIG_IsOK(res1)) {
24348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24349 }
24350 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24351 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24352 if (!SWIG_IsOK(ecode2)) {
24353 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
24354 }
24355 arg2 = static_cast< bool >(val2);
24356 if (arg1) (arg1)->m_altDown = arg2;
24357
24358 resultobj = SWIG_Py_Void();
24359 return resultobj;
24360 fail:
24361 return NULL;
24362 }
24363
24364
24365 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24366 PyObject *resultobj = 0;
24367 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24368 bool result;
24369 void *argp1 = 0 ;
24370 int res1 = 0 ;
24371 PyObject *swig_obj[1] ;
24372
24373 if (!args) SWIG_fail;
24374 swig_obj[0] = args;
24375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24376 if (!SWIG_IsOK(res1)) {
24377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24378 }
24379 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24380 result = (bool) ((arg1)->m_altDown);
24381 {
24382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24383 }
24384 return resultobj;
24385 fail:
24386 return NULL;
24387 }
24388
24389
24390 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24391 PyObject *resultobj = 0;
24392 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24393 bool arg2 ;
24394 void *argp1 = 0 ;
24395 int res1 = 0 ;
24396 bool val2 ;
24397 int ecode2 = 0 ;
24398 PyObject *swig_obj[2] ;
24399
24400 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
24401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24402 if (!SWIG_IsOK(res1)) {
24403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24404 }
24405 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24406 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24407 if (!SWIG_IsOK(ecode2)) {
24408 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
24409 }
24410 arg2 = static_cast< bool >(val2);
24411 if (arg1) (arg1)->m_metaDown = arg2;
24412
24413 resultobj = SWIG_Py_Void();
24414 return resultobj;
24415 fail:
24416 return NULL;
24417 }
24418
24419
24420 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24421 PyObject *resultobj = 0;
24422 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24423 bool result;
24424 void *argp1 = 0 ;
24425 int res1 = 0 ;
24426 PyObject *swig_obj[1] ;
24427
24428 if (!args) SWIG_fail;
24429 swig_obj[0] = args;
24430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24431 if (!SWIG_IsOK(res1)) {
24432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24433 }
24434 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24435 result = (bool) ((arg1)->m_metaDown);
24436 {
24437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24438 }
24439 return resultobj;
24440 fail:
24441 return NULL;
24442 }
24443
24444
24445 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24446 PyObject *resultobj = 0;
24447 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24448 int arg2 ;
24449 void *argp1 = 0 ;
24450 int res1 = 0 ;
24451 int val2 ;
24452 int ecode2 = 0 ;
24453 PyObject *swig_obj[2] ;
24454
24455 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
24456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24457 if (!SWIG_IsOK(res1)) {
24458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24459 }
24460 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24461 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24462 if (!SWIG_IsOK(ecode2)) {
24463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
24464 }
24465 arg2 = static_cast< int >(val2);
24466 if (arg1) (arg1)->m_wheelRotation = arg2;
24467
24468 resultobj = SWIG_Py_Void();
24469 return resultobj;
24470 fail:
24471 return NULL;
24472 }
24473
24474
24475 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24476 PyObject *resultobj = 0;
24477 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24478 int result;
24479 void *argp1 = 0 ;
24480 int res1 = 0 ;
24481 PyObject *swig_obj[1] ;
24482
24483 if (!args) SWIG_fail;
24484 swig_obj[0] = args;
24485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24486 if (!SWIG_IsOK(res1)) {
24487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24488 }
24489 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24490 result = (int) ((arg1)->m_wheelRotation);
24491 resultobj = SWIG_From_int(static_cast< int >(result));
24492 return resultobj;
24493 fail:
24494 return NULL;
24495 }
24496
24497
24498 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24499 PyObject *resultobj = 0;
24500 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24501 int arg2 ;
24502 void *argp1 = 0 ;
24503 int res1 = 0 ;
24504 int val2 ;
24505 int ecode2 = 0 ;
24506 PyObject *swig_obj[2] ;
24507
24508 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
24509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24510 if (!SWIG_IsOK(res1)) {
24511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24512 }
24513 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24514 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24515 if (!SWIG_IsOK(ecode2)) {
24516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
24517 }
24518 arg2 = static_cast< int >(val2);
24519 if (arg1) (arg1)->m_wheelDelta = arg2;
24520
24521 resultobj = SWIG_Py_Void();
24522 return resultobj;
24523 fail:
24524 return NULL;
24525 }
24526
24527
24528 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24529 PyObject *resultobj = 0;
24530 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24531 int result;
24532 void *argp1 = 0 ;
24533 int res1 = 0 ;
24534 PyObject *swig_obj[1] ;
24535
24536 if (!args) SWIG_fail;
24537 swig_obj[0] = args;
24538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24539 if (!SWIG_IsOK(res1)) {
24540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24541 }
24542 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24543 result = (int) ((arg1)->m_wheelDelta);
24544 resultobj = SWIG_From_int(static_cast< int >(result));
24545 return resultobj;
24546 fail:
24547 return NULL;
24548 }
24549
24550
24551 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24552 PyObject *resultobj = 0;
24553 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24554 int arg2 ;
24555 void *argp1 = 0 ;
24556 int res1 = 0 ;
24557 int val2 ;
24558 int ecode2 = 0 ;
24559 PyObject *swig_obj[2] ;
24560
24561 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
24562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24563 if (!SWIG_IsOK(res1)) {
24564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24565 }
24566 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24567 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24568 if (!SWIG_IsOK(ecode2)) {
24569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
24570 }
24571 arg2 = static_cast< int >(val2);
24572 if (arg1) (arg1)->m_linesPerAction = arg2;
24573
24574 resultobj = SWIG_Py_Void();
24575 return resultobj;
24576 fail:
24577 return NULL;
24578 }
24579
24580
24581 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24582 PyObject *resultobj = 0;
24583 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24584 int result;
24585 void *argp1 = 0 ;
24586 int res1 = 0 ;
24587 PyObject *swig_obj[1] ;
24588
24589 if (!args) SWIG_fail;
24590 swig_obj[0] = args;
24591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24592 if (!SWIG_IsOK(res1)) {
24593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24594 }
24595 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24596 result = (int) ((arg1)->m_linesPerAction);
24597 resultobj = SWIG_From_int(static_cast< int >(result));
24598 return resultobj;
24599 fail:
24600 return NULL;
24601 }
24602
24603
24604 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24605 PyObject *obj;
24606 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24607 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
24608 return SWIG_Py_Void();
24609 }
24610
24611 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24612 return SWIG_Python_InitShadowInstance(args);
24613 }
24614
24615 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24616 PyObject *resultobj = 0;
24617 int arg1 = (int) 0 ;
24618 int arg2 = (int) 0 ;
24619 wxSetCursorEvent *result = 0 ;
24620 int val1 ;
24621 int ecode1 = 0 ;
24622 int val2 ;
24623 int ecode2 = 0 ;
24624 PyObject * obj0 = 0 ;
24625 PyObject * obj1 = 0 ;
24626 char * kwnames[] = {
24627 (char *) "x",(char *) "y", NULL
24628 };
24629
24630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24631 if (obj0) {
24632 ecode1 = SWIG_AsVal_int(obj0, &val1);
24633 if (!SWIG_IsOK(ecode1)) {
24634 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
24635 }
24636 arg1 = static_cast< int >(val1);
24637 }
24638 if (obj1) {
24639 ecode2 = SWIG_AsVal_int(obj1, &val2);
24640 if (!SWIG_IsOK(ecode2)) {
24641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
24642 }
24643 arg2 = static_cast< int >(val2);
24644 }
24645 {
24646 PyThreadState* __tstate = wxPyBeginAllowThreads();
24647 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
24648 wxPyEndAllowThreads(__tstate);
24649 if (PyErr_Occurred()) SWIG_fail;
24650 }
24651 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
24652 return resultobj;
24653 fail:
24654 return NULL;
24655 }
24656
24657
24658 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24659 PyObject *resultobj = 0;
24660 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24661 int result;
24662 void *argp1 = 0 ;
24663 int res1 = 0 ;
24664 PyObject *swig_obj[1] ;
24665
24666 if (!args) SWIG_fail;
24667 swig_obj[0] = args;
24668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24669 if (!SWIG_IsOK(res1)) {
24670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24671 }
24672 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24673 {
24674 PyThreadState* __tstate = wxPyBeginAllowThreads();
24675 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
24676 wxPyEndAllowThreads(__tstate);
24677 if (PyErr_Occurred()) SWIG_fail;
24678 }
24679 resultobj = SWIG_From_int(static_cast< int >(result));
24680 return resultobj;
24681 fail:
24682 return NULL;
24683 }
24684
24685
24686 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24687 PyObject *resultobj = 0;
24688 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24689 int result;
24690 void *argp1 = 0 ;
24691 int res1 = 0 ;
24692 PyObject *swig_obj[1] ;
24693
24694 if (!args) SWIG_fail;
24695 swig_obj[0] = args;
24696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24697 if (!SWIG_IsOK(res1)) {
24698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24699 }
24700 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24701 {
24702 PyThreadState* __tstate = wxPyBeginAllowThreads();
24703 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
24704 wxPyEndAllowThreads(__tstate);
24705 if (PyErr_Occurred()) SWIG_fail;
24706 }
24707 resultobj = SWIG_From_int(static_cast< int >(result));
24708 return resultobj;
24709 fail:
24710 return NULL;
24711 }
24712
24713
24714 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24715 PyObject *resultobj = 0;
24716 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24717 wxCursor *arg2 = 0 ;
24718 void *argp1 = 0 ;
24719 int res1 = 0 ;
24720 void *argp2 = 0 ;
24721 int res2 = 0 ;
24722 PyObject * obj0 = 0 ;
24723 PyObject * obj1 = 0 ;
24724 char * kwnames[] = {
24725 (char *) "self",(char *) "cursor", NULL
24726 };
24727
24728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
24729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24730 if (!SWIG_IsOK(res1)) {
24731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
24732 }
24733 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24734 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
24735 if (!SWIG_IsOK(res2)) {
24736 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24737 }
24738 if (!argp2) {
24739 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24740 }
24741 arg2 = reinterpret_cast< wxCursor * >(argp2);
24742 {
24743 PyThreadState* __tstate = wxPyBeginAllowThreads();
24744 (arg1)->SetCursor((wxCursor const &)*arg2);
24745 wxPyEndAllowThreads(__tstate);
24746 if (PyErr_Occurred()) SWIG_fail;
24747 }
24748 resultobj = SWIG_Py_Void();
24749 return resultobj;
24750 fail:
24751 return NULL;
24752 }
24753
24754
24755 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24756 PyObject *resultobj = 0;
24757 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24758 wxCursor *result = 0 ;
24759 void *argp1 = 0 ;
24760 int res1 = 0 ;
24761 PyObject *swig_obj[1] ;
24762
24763 if (!args) SWIG_fail;
24764 swig_obj[0] = args;
24765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24766 if (!SWIG_IsOK(res1)) {
24767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24768 }
24769 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24770 {
24771 PyThreadState* __tstate = wxPyBeginAllowThreads();
24772 {
24773 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
24774 result = (wxCursor *) &_result_ref;
24775 }
24776 wxPyEndAllowThreads(__tstate);
24777 if (PyErr_Occurred()) SWIG_fail;
24778 }
24779 {
24780 wxCursor* resultptr = new wxCursor(*result);
24781 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
24782 }
24783 return resultobj;
24784 fail:
24785 return NULL;
24786 }
24787
24788
24789 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24790 PyObject *resultobj = 0;
24791 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24792 bool result;
24793 void *argp1 = 0 ;
24794 int res1 = 0 ;
24795 PyObject *swig_obj[1] ;
24796
24797 if (!args) SWIG_fail;
24798 swig_obj[0] = args;
24799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24800 if (!SWIG_IsOK(res1)) {
24801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24802 }
24803 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24804 {
24805 PyThreadState* __tstate = wxPyBeginAllowThreads();
24806 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
24807 wxPyEndAllowThreads(__tstate);
24808 if (PyErr_Occurred()) SWIG_fail;
24809 }
24810 {
24811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24812 }
24813 return resultobj;
24814 fail:
24815 return NULL;
24816 }
24817
24818
24819 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24820 PyObject *obj;
24821 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24822 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
24823 return SWIG_Py_Void();
24824 }
24825
24826 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24827 return SWIG_Python_InitShadowInstance(args);
24828 }
24829
24830 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24831 PyObject *resultobj = 0;
24832 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24833 wxKeyEvent *result = 0 ;
24834 int val1 ;
24835 int ecode1 = 0 ;
24836 PyObject * obj0 = 0 ;
24837 char * kwnames[] = {
24838 (char *) "eventType", NULL
24839 };
24840
24841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
24842 if (obj0) {
24843 ecode1 = SWIG_AsVal_int(obj0, &val1);
24844 if (!SWIG_IsOK(ecode1)) {
24845 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24846 }
24847 arg1 = static_cast< wxEventType >(val1);
24848 }
24849 {
24850 PyThreadState* __tstate = wxPyBeginAllowThreads();
24851 result = (wxKeyEvent *)new wxKeyEvent(arg1);
24852 wxPyEndAllowThreads(__tstate);
24853 if (PyErr_Occurred()) SWIG_fail;
24854 }
24855 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
24856 return resultobj;
24857 fail:
24858 return NULL;
24859 }
24860
24861
24862 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24863 PyObject *resultobj = 0;
24864 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24865 int result;
24866 void *argp1 = 0 ;
24867 int res1 = 0 ;
24868 PyObject *swig_obj[1] ;
24869
24870 if (!args) SWIG_fail;
24871 swig_obj[0] = args;
24872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24873 if (!SWIG_IsOK(res1)) {
24874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24875 }
24876 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24877 {
24878 PyThreadState* __tstate = wxPyBeginAllowThreads();
24879 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
24880 wxPyEndAllowThreads(__tstate);
24881 if (PyErr_Occurred()) SWIG_fail;
24882 }
24883 resultobj = SWIG_From_int(static_cast< int >(result));
24884 return resultobj;
24885 fail:
24886 return NULL;
24887 }
24888
24889
24890 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24891 PyObject *resultobj = 0;
24892 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24893 bool result;
24894 void *argp1 = 0 ;
24895 int res1 = 0 ;
24896 PyObject *swig_obj[1] ;
24897
24898 if (!args) SWIG_fail;
24899 swig_obj[0] = args;
24900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24901 if (!SWIG_IsOK(res1)) {
24902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24903 }
24904 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24905 {
24906 PyThreadState* __tstate = wxPyBeginAllowThreads();
24907 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
24908 wxPyEndAllowThreads(__tstate);
24909 if (PyErr_Occurred()) SWIG_fail;
24910 }
24911 {
24912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24913 }
24914 return resultobj;
24915 fail:
24916 return NULL;
24917 }
24918
24919
24920 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24921 PyObject *resultobj = 0;
24922 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24923 bool result;
24924 void *argp1 = 0 ;
24925 int res1 = 0 ;
24926 PyObject *swig_obj[1] ;
24927
24928 if (!args) SWIG_fail;
24929 swig_obj[0] = args;
24930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24931 if (!SWIG_IsOK(res1)) {
24932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24933 }
24934 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24935 {
24936 PyThreadState* __tstate = wxPyBeginAllowThreads();
24937 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
24938 wxPyEndAllowThreads(__tstate);
24939 if (PyErr_Occurred()) SWIG_fail;
24940 }
24941 {
24942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24943 }
24944 return resultobj;
24945 fail:
24946 return NULL;
24947 }
24948
24949
24950 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24951 PyObject *resultobj = 0;
24952 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24953 bool result;
24954 void *argp1 = 0 ;
24955 int res1 = 0 ;
24956 PyObject *swig_obj[1] ;
24957
24958 if (!args) SWIG_fail;
24959 swig_obj[0] = args;
24960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24961 if (!SWIG_IsOK(res1)) {
24962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24963 }
24964 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24965 {
24966 PyThreadState* __tstate = wxPyBeginAllowThreads();
24967 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
24968 wxPyEndAllowThreads(__tstate);
24969 if (PyErr_Occurred()) SWIG_fail;
24970 }
24971 {
24972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24973 }
24974 return resultobj;
24975 fail:
24976 return NULL;
24977 }
24978
24979
24980 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24981 PyObject *resultobj = 0;
24982 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24983 bool result;
24984 void *argp1 = 0 ;
24985 int res1 = 0 ;
24986 PyObject *swig_obj[1] ;
24987
24988 if (!args) SWIG_fail;
24989 swig_obj[0] = args;
24990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24991 if (!SWIG_IsOK(res1)) {
24992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24993 }
24994 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24995 {
24996 PyThreadState* __tstate = wxPyBeginAllowThreads();
24997 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
24998 wxPyEndAllowThreads(__tstate);
24999 if (PyErr_Occurred()) SWIG_fail;
25000 }
25001 {
25002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25003 }
25004 return resultobj;
25005 fail:
25006 return NULL;
25007 }
25008
25009
25010 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25011 PyObject *resultobj = 0;
25012 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25013 bool result;
25014 void *argp1 = 0 ;
25015 int res1 = 0 ;
25016 PyObject *swig_obj[1] ;
25017
25018 if (!args) SWIG_fail;
25019 swig_obj[0] = args;
25020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25021 if (!SWIG_IsOK(res1)) {
25022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25023 }
25024 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25025 {
25026 PyThreadState* __tstate = wxPyBeginAllowThreads();
25027 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
25028 wxPyEndAllowThreads(__tstate);
25029 if (PyErr_Occurred()) SWIG_fail;
25030 }
25031 {
25032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25033 }
25034 return resultobj;
25035 fail:
25036 return NULL;
25037 }
25038
25039
25040 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25041 PyObject *resultobj = 0;
25042 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25043 bool result;
25044 void *argp1 = 0 ;
25045 int res1 = 0 ;
25046 PyObject *swig_obj[1] ;
25047
25048 if (!args) SWIG_fail;
25049 swig_obj[0] = args;
25050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25051 if (!SWIG_IsOK(res1)) {
25052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25053 }
25054 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25055 {
25056 PyThreadState* __tstate = wxPyBeginAllowThreads();
25057 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
25058 wxPyEndAllowThreads(__tstate);
25059 if (PyErr_Occurred()) SWIG_fail;
25060 }
25061 {
25062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25063 }
25064 return resultobj;
25065 fail:
25066 return NULL;
25067 }
25068
25069
25070 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25071 PyObject *resultobj = 0;
25072 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25073 int result;
25074 void *argp1 = 0 ;
25075 int res1 = 0 ;
25076 PyObject *swig_obj[1] ;
25077
25078 if (!args) SWIG_fail;
25079 swig_obj[0] = args;
25080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25081 if (!SWIG_IsOK(res1)) {
25082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25083 }
25084 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25085 {
25086 PyThreadState* __tstate = wxPyBeginAllowThreads();
25087 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
25088 wxPyEndAllowThreads(__tstate);
25089 if (PyErr_Occurred()) SWIG_fail;
25090 }
25091 resultobj = SWIG_From_int(static_cast< int >(result));
25092 return resultobj;
25093 fail:
25094 return NULL;
25095 }
25096
25097
25098 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25099 PyObject *resultobj = 0;
25100 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25101 int result;
25102 void *argp1 = 0 ;
25103 int res1 = 0 ;
25104 PyObject *swig_obj[1] ;
25105
25106 if (!args) SWIG_fail;
25107 swig_obj[0] = args;
25108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25109 if (!SWIG_IsOK(res1)) {
25110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25111 }
25112 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25113 {
25114 PyThreadState* __tstate = wxPyBeginAllowThreads();
25115 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
25116 wxPyEndAllowThreads(__tstate);
25117 if (PyErr_Occurred()) SWIG_fail;
25118 }
25119 resultobj = SWIG_From_int(static_cast< int >(result));
25120 return resultobj;
25121 fail:
25122 return NULL;
25123 }
25124
25125
25126 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25127 PyObject *resultobj = 0;
25128 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25129 int arg2 ;
25130 void *argp1 = 0 ;
25131 int res1 = 0 ;
25132 int val2 ;
25133 int ecode2 = 0 ;
25134 PyObject * obj0 = 0 ;
25135 PyObject * obj1 = 0 ;
25136 char * kwnames[] = {
25137 (char *) "self",(char *) "uniChar", NULL
25138 };
25139
25140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
25141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25142 if (!SWIG_IsOK(res1)) {
25143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25144 }
25145 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25146 ecode2 = SWIG_AsVal_int(obj1, &val2);
25147 if (!SWIG_IsOK(ecode2)) {
25148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
25149 }
25150 arg2 = static_cast< int >(val2);
25151 {
25152 PyThreadState* __tstate = wxPyBeginAllowThreads();
25153 wxKeyEvent_SetUnicodeKey(arg1,arg2);
25154 wxPyEndAllowThreads(__tstate);
25155 if (PyErr_Occurred()) SWIG_fail;
25156 }
25157 resultobj = SWIG_Py_Void();
25158 return resultobj;
25159 fail:
25160 return NULL;
25161 }
25162
25163
25164 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25165 PyObject *resultobj = 0;
25166 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25167 unsigned int result;
25168 void *argp1 = 0 ;
25169 int res1 = 0 ;
25170 PyObject *swig_obj[1] ;
25171
25172 if (!args) SWIG_fail;
25173 swig_obj[0] = args;
25174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25175 if (!SWIG_IsOK(res1)) {
25176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25177 }
25178 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25179 {
25180 PyThreadState* __tstate = wxPyBeginAllowThreads();
25181 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
25182 wxPyEndAllowThreads(__tstate);
25183 if (PyErr_Occurred()) SWIG_fail;
25184 }
25185 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25186 return resultobj;
25187 fail:
25188 return NULL;
25189 }
25190
25191
25192 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25193 PyObject *resultobj = 0;
25194 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25195 unsigned int result;
25196 void *argp1 = 0 ;
25197 int res1 = 0 ;
25198 PyObject *swig_obj[1] ;
25199
25200 if (!args) SWIG_fail;
25201 swig_obj[0] = args;
25202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25203 if (!SWIG_IsOK(res1)) {
25204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25205 }
25206 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25207 {
25208 PyThreadState* __tstate = wxPyBeginAllowThreads();
25209 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
25210 wxPyEndAllowThreads(__tstate);
25211 if (PyErr_Occurred()) SWIG_fail;
25212 }
25213 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25214 return resultobj;
25215 fail:
25216 return NULL;
25217 }
25218
25219
25220 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25221 PyObject *resultobj = 0;
25222 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25223 wxPoint result;
25224 void *argp1 = 0 ;
25225 int res1 = 0 ;
25226 PyObject *swig_obj[1] ;
25227
25228 if (!args) SWIG_fail;
25229 swig_obj[0] = args;
25230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25231 if (!SWIG_IsOK(res1)) {
25232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25233 }
25234 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25235 {
25236 PyThreadState* __tstate = wxPyBeginAllowThreads();
25237 result = (arg1)->GetPosition();
25238 wxPyEndAllowThreads(__tstate);
25239 if (PyErr_Occurred()) SWIG_fail;
25240 }
25241 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25242 return resultobj;
25243 fail:
25244 return NULL;
25245 }
25246
25247
25248 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25249 PyObject *resultobj = 0;
25250 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25251 long *arg2 = (long *) 0 ;
25252 long *arg3 = (long *) 0 ;
25253 void *argp1 = 0 ;
25254 int res1 = 0 ;
25255 long temp2 ;
25256 int res2 = SWIG_TMPOBJ ;
25257 long temp3 ;
25258 int res3 = SWIG_TMPOBJ ;
25259 PyObject *swig_obj[1] ;
25260
25261 arg2 = &temp2;
25262 arg3 = &temp3;
25263 if (!args) SWIG_fail;
25264 swig_obj[0] = args;
25265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25266 if (!SWIG_IsOK(res1)) {
25267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25268 }
25269 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25270 {
25271 PyThreadState* __tstate = wxPyBeginAllowThreads();
25272 (arg1)->GetPosition(arg2,arg3);
25273 wxPyEndAllowThreads(__tstate);
25274 if (PyErr_Occurred()) SWIG_fail;
25275 }
25276 resultobj = SWIG_Py_Void();
25277 if (SWIG_IsTmpObj(res2)) {
25278 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
25279 } else {
25280 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25281 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
25282 }
25283 if (SWIG_IsTmpObj(res3)) {
25284 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
25285 } else {
25286 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25287 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
25288 }
25289 return resultobj;
25290 fail:
25291 return NULL;
25292 }
25293
25294
25295 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25296 PyObject *resultobj = 0;
25297 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25298 int result;
25299 void *argp1 = 0 ;
25300 int res1 = 0 ;
25301 PyObject *swig_obj[1] ;
25302
25303 if (!args) SWIG_fail;
25304 swig_obj[0] = args;
25305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25306 if (!SWIG_IsOK(res1)) {
25307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25308 }
25309 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25310 {
25311 PyThreadState* __tstate = wxPyBeginAllowThreads();
25312 result = (int)((wxKeyEvent const *)arg1)->GetX();
25313 wxPyEndAllowThreads(__tstate);
25314 if (PyErr_Occurred()) SWIG_fail;
25315 }
25316 resultobj = SWIG_From_int(static_cast< int >(result));
25317 return resultobj;
25318 fail:
25319 return NULL;
25320 }
25321
25322
25323 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25324 PyObject *resultobj = 0;
25325 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25326 int result;
25327 void *argp1 = 0 ;
25328 int res1 = 0 ;
25329 PyObject *swig_obj[1] ;
25330
25331 if (!args) SWIG_fail;
25332 swig_obj[0] = args;
25333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25334 if (!SWIG_IsOK(res1)) {
25335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25336 }
25337 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25338 {
25339 PyThreadState* __tstate = wxPyBeginAllowThreads();
25340 result = (int)((wxKeyEvent const *)arg1)->GetY();
25341 wxPyEndAllowThreads(__tstate);
25342 if (PyErr_Occurred()) SWIG_fail;
25343 }
25344 resultobj = SWIG_From_int(static_cast< int >(result));
25345 return resultobj;
25346 fail:
25347 return NULL;
25348 }
25349
25350
25351 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25352 PyObject *resultobj = 0;
25353 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25354 int arg2 ;
25355 void *argp1 = 0 ;
25356 int res1 = 0 ;
25357 int val2 ;
25358 int ecode2 = 0 ;
25359 PyObject *swig_obj[2] ;
25360
25361 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
25362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25363 if (!SWIG_IsOK(res1)) {
25364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25365 }
25366 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25367 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25368 if (!SWIG_IsOK(ecode2)) {
25369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
25370 }
25371 arg2 = static_cast< int >(val2);
25372 if (arg1) (arg1)->m_x = arg2;
25373
25374 resultobj = SWIG_Py_Void();
25375 return resultobj;
25376 fail:
25377 return NULL;
25378 }
25379
25380
25381 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25382 PyObject *resultobj = 0;
25383 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25384 int result;
25385 void *argp1 = 0 ;
25386 int res1 = 0 ;
25387 PyObject *swig_obj[1] ;
25388
25389 if (!args) SWIG_fail;
25390 swig_obj[0] = args;
25391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25392 if (!SWIG_IsOK(res1)) {
25393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25394 }
25395 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25396 result = (int) ((arg1)->m_x);
25397 resultobj = SWIG_From_int(static_cast< int >(result));
25398 return resultobj;
25399 fail:
25400 return NULL;
25401 }
25402
25403
25404 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25405 PyObject *resultobj = 0;
25406 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25407 int arg2 ;
25408 void *argp1 = 0 ;
25409 int res1 = 0 ;
25410 int val2 ;
25411 int ecode2 = 0 ;
25412 PyObject *swig_obj[2] ;
25413
25414 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
25415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25416 if (!SWIG_IsOK(res1)) {
25417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25418 }
25419 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25420 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25421 if (!SWIG_IsOK(ecode2)) {
25422 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
25423 }
25424 arg2 = static_cast< int >(val2);
25425 if (arg1) (arg1)->m_y = arg2;
25426
25427 resultobj = SWIG_Py_Void();
25428 return resultobj;
25429 fail:
25430 return NULL;
25431 }
25432
25433
25434 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25435 PyObject *resultobj = 0;
25436 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25437 int result;
25438 void *argp1 = 0 ;
25439 int res1 = 0 ;
25440 PyObject *swig_obj[1] ;
25441
25442 if (!args) SWIG_fail;
25443 swig_obj[0] = args;
25444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25445 if (!SWIG_IsOK(res1)) {
25446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25447 }
25448 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25449 result = (int) ((arg1)->m_y);
25450 resultobj = SWIG_From_int(static_cast< int >(result));
25451 return resultobj;
25452 fail:
25453 return NULL;
25454 }
25455
25456
25457 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25458 PyObject *resultobj = 0;
25459 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25460 long arg2 ;
25461 void *argp1 = 0 ;
25462 int res1 = 0 ;
25463 long val2 ;
25464 int ecode2 = 0 ;
25465 PyObject *swig_obj[2] ;
25466
25467 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
25468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25469 if (!SWIG_IsOK(res1)) {
25470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25471 }
25472 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25473 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
25474 if (!SWIG_IsOK(ecode2)) {
25475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
25476 }
25477 arg2 = static_cast< long >(val2);
25478 if (arg1) (arg1)->m_keyCode = arg2;
25479
25480 resultobj = SWIG_Py_Void();
25481 return resultobj;
25482 fail:
25483 return NULL;
25484 }
25485
25486
25487 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25488 PyObject *resultobj = 0;
25489 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25490 long result;
25491 void *argp1 = 0 ;
25492 int res1 = 0 ;
25493 PyObject *swig_obj[1] ;
25494
25495 if (!args) SWIG_fail;
25496 swig_obj[0] = args;
25497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25498 if (!SWIG_IsOK(res1)) {
25499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25500 }
25501 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25502 result = (long) ((arg1)->m_keyCode);
25503 resultobj = SWIG_From_long(static_cast< long >(result));
25504 return resultobj;
25505 fail:
25506 return NULL;
25507 }
25508
25509
25510 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25511 PyObject *resultobj = 0;
25512 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25513 bool arg2 ;
25514 void *argp1 = 0 ;
25515 int res1 = 0 ;
25516 bool val2 ;
25517 int ecode2 = 0 ;
25518 PyObject *swig_obj[2] ;
25519
25520 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
25521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25522 if (!SWIG_IsOK(res1)) {
25523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25524 }
25525 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25526 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25527 if (!SWIG_IsOK(ecode2)) {
25528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
25529 }
25530 arg2 = static_cast< bool >(val2);
25531 if (arg1) (arg1)->m_controlDown = arg2;
25532
25533 resultobj = SWIG_Py_Void();
25534 return resultobj;
25535 fail:
25536 return NULL;
25537 }
25538
25539
25540 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25541 PyObject *resultobj = 0;
25542 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25543 bool result;
25544 void *argp1 = 0 ;
25545 int res1 = 0 ;
25546 PyObject *swig_obj[1] ;
25547
25548 if (!args) SWIG_fail;
25549 swig_obj[0] = args;
25550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25551 if (!SWIG_IsOK(res1)) {
25552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25553 }
25554 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25555 result = (bool) ((arg1)->m_controlDown);
25556 {
25557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25558 }
25559 return resultobj;
25560 fail:
25561 return NULL;
25562 }
25563
25564
25565 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25566 PyObject *resultobj = 0;
25567 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25568 bool arg2 ;
25569 void *argp1 = 0 ;
25570 int res1 = 0 ;
25571 bool val2 ;
25572 int ecode2 = 0 ;
25573 PyObject *swig_obj[2] ;
25574
25575 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
25576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25577 if (!SWIG_IsOK(res1)) {
25578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25579 }
25580 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25581 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25582 if (!SWIG_IsOK(ecode2)) {
25583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
25584 }
25585 arg2 = static_cast< bool >(val2);
25586 if (arg1) (arg1)->m_shiftDown = arg2;
25587
25588 resultobj = SWIG_Py_Void();
25589 return resultobj;
25590 fail:
25591 return NULL;
25592 }
25593
25594
25595 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25596 PyObject *resultobj = 0;
25597 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25598 bool result;
25599 void *argp1 = 0 ;
25600 int res1 = 0 ;
25601 PyObject *swig_obj[1] ;
25602
25603 if (!args) SWIG_fail;
25604 swig_obj[0] = args;
25605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25606 if (!SWIG_IsOK(res1)) {
25607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25608 }
25609 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25610 result = (bool) ((arg1)->m_shiftDown);
25611 {
25612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25613 }
25614 return resultobj;
25615 fail:
25616 return NULL;
25617 }
25618
25619
25620 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25621 PyObject *resultobj = 0;
25622 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25623 bool arg2 ;
25624 void *argp1 = 0 ;
25625 int res1 = 0 ;
25626 bool val2 ;
25627 int ecode2 = 0 ;
25628 PyObject *swig_obj[2] ;
25629
25630 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
25631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25632 if (!SWIG_IsOK(res1)) {
25633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25634 }
25635 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25636 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25637 if (!SWIG_IsOK(ecode2)) {
25638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
25639 }
25640 arg2 = static_cast< bool >(val2);
25641 if (arg1) (arg1)->m_altDown = arg2;
25642
25643 resultobj = SWIG_Py_Void();
25644 return resultobj;
25645 fail:
25646 return NULL;
25647 }
25648
25649
25650 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25651 PyObject *resultobj = 0;
25652 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25653 bool result;
25654 void *argp1 = 0 ;
25655 int res1 = 0 ;
25656 PyObject *swig_obj[1] ;
25657
25658 if (!args) SWIG_fail;
25659 swig_obj[0] = args;
25660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25661 if (!SWIG_IsOK(res1)) {
25662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25663 }
25664 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25665 result = (bool) ((arg1)->m_altDown);
25666 {
25667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25668 }
25669 return resultobj;
25670 fail:
25671 return NULL;
25672 }
25673
25674
25675 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25676 PyObject *resultobj = 0;
25677 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25678 bool arg2 ;
25679 void *argp1 = 0 ;
25680 int res1 = 0 ;
25681 bool val2 ;
25682 int ecode2 = 0 ;
25683 PyObject *swig_obj[2] ;
25684
25685 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
25686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25687 if (!SWIG_IsOK(res1)) {
25688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25689 }
25690 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25691 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25692 if (!SWIG_IsOK(ecode2)) {
25693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
25694 }
25695 arg2 = static_cast< bool >(val2);
25696 if (arg1) (arg1)->m_metaDown = arg2;
25697
25698 resultobj = SWIG_Py_Void();
25699 return resultobj;
25700 fail:
25701 return NULL;
25702 }
25703
25704
25705 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25706 PyObject *resultobj = 0;
25707 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25708 bool result;
25709 void *argp1 = 0 ;
25710 int res1 = 0 ;
25711 PyObject *swig_obj[1] ;
25712
25713 if (!args) SWIG_fail;
25714 swig_obj[0] = args;
25715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25716 if (!SWIG_IsOK(res1)) {
25717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25718 }
25719 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25720 result = (bool) ((arg1)->m_metaDown);
25721 {
25722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25723 }
25724 return resultobj;
25725 fail:
25726 return NULL;
25727 }
25728
25729
25730 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25731 PyObject *resultobj = 0;
25732 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25733 bool arg2 ;
25734 void *argp1 = 0 ;
25735 int res1 = 0 ;
25736 bool val2 ;
25737 int ecode2 = 0 ;
25738 PyObject *swig_obj[2] ;
25739
25740 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
25741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25742 if (!SWIG_IsOK(res1)) {
25743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25744 }
25745 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25746 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25747 if (!SWIG_IsOK(ecode2)) {
25748 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
25749 }
25750 arg2 = static_cast< bool >(val2);
25751 if (arg1) (arg1)->m_scanCode = arg2;
25752
25753 resultobj = SWIG_Py_Void();
25754 return resultobj;
25755 fail:
25756 return NULL;
25757 }
25758
25759
25760 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25761 PyObject *resultobj = 0;
25762 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25763 bool result;
25764 void *argp1 = 0 ;
25765 int res1 = 0 ;
25766 PyObject *swig_obj[1] ;
25767
25768 if (!args) SWIG_fail;
25769 swig_obj[0] = args;
25770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25771 if (!SWIG_IsOK(res1)) {
25772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25773 }
25774 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25775 result = (bool) ((arg1)->m_scanCode);
25776 {
25777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25778 }
25779 return resultobj;
25780 fail:
25781 return NULL;
25782 }
25783
25784
25785 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25786 PyObject *resultobj = 0;
25787 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25788 unsigned int arg2 ;
25789 void *argp1 = 0 ;
25790 int res1 = 0 ;
25791 unsigned int val2 ;
25792 int ecode2 = 0 ;
25793 PyObject *swig_obj[2] ;
25794
25795 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
25796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25797 if (!SWIG_IsOK(res1)) {
25798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25799 }
25800 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25801 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25802 if (!SWIG_IsOK(ecode2)) {
25803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
25804 }
25805 arg2 = static_cast< unsigned int >(val2);
25806 if (arg1) (arg1)->m_rawCode = arg2;
25807
25808 resultobj = SWIG_Py_Void();
25809 return resultobj;
25810 fail:
25811 return NULL;
25812 }
25813
25814
25815 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25816 PyObject *resultobj = 0;
25817 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25818 unsigned int result;
25819 void *argp1 = 0 ;
25820 int res1 = 0 ;
25821 PyObject *swig_obj[1] ;
25822
25823 if (!args) SWIG_fail;
25824 swig_obj[0] = args;
25825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25826 if (!SWIG_IsOK(res1)) {
25827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25828 }
25829 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25830 result = (unsigned int) ((arg1)->m_rawCode);
25831 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25832 return resultobj;
25833 fail:
25834 return NULL;
25835 }
25836
25837
25838 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25839 PyObject *resultobj = 0;
25840 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25841 unsigned int arg2 ;
25842 void *argp1 = 0 ;
25843 int res1 = 0 ;
25844 unsigned int val2 ;
25845 int ecode2 = 0 ;
25846 PyObject *swig_obj[2] ;
25847
25848 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
25849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25850 if (!SWIG_IsOK(res1)) {
25851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25852 }
25853 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25854 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25855 if (!SWIG_IsOK(ecode2)) {
25856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
25857 }
25858 arg2 = static_cast< unsigned int >(val2);
25859 if (arg1) (arg1)->m_rawFlags = arg2;
25860
25861 resultobj = SWIG_Py_Void();
25862 return resultobj;
25863 fail:
25864 return NULL;
25865 }
25866
25867
25868 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25869 PyObject *resultobj = 0;
25870 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25871 unsigned int result;
25872 void *argp1 = 0 ;
25873 int res1 = 0 ;
25874 PyObject *swig_obj[1] ;
25875
25876 if (!args) SWIG_fail;
25877 swig_obj[0] = args;
25878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25879 if (!SWIG_IsOK(res1)) {
25880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25881 }
25882 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25883 result = (unsigned int) ((arg1)->m_rawFlags);
25884 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25885 return resultobj;
25886 fail:
25887 return NULL;
25888 }
25889
25890
25891 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25892 PyObject *obj;
25893 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25894 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
25895 return SWIG_Py_Void();
25896 }
25897
25898 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25899 return SWIG_Python_InitShadowInstance(args);
25900 }
25901
25902 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25903 PyObject *resultobj = 0;
25904 wxSize const &arg1_defvalue = wxDefaultSize ;
25905 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
25906 int arg2 = (int) 0 ;
25907 wxSizeEvent *result = 0 ;
25908 wxSize temp1 ;
25909 int val2 ;
25910 int ecode2 = 0 ;
25911 PyObject * obj0 = 0 ;
25912 PyObject * obj1 = 0 ;
25913 char * kwnames[] = {
25914 (char *) "sz",(char *) "winid", NULL
25915 };
25916
25917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25918 if (obj0) {
25919 {
25920 arg1 = &temp1;
25921 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
25922 }
25923 }
25924 if (obj1) {
25925 ecode2 = SWIG_AsVal_int(obj1, &val2);
25926 if (!SWIG_IsOK(ecode2)) {
25927 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
25928 }
25929 arg2 = static_cast< int >(val2);
25930 }
25931 {
25932 PyThreadState* __tstate = wxPyBeginAllowThreads();
25933 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
25934 wxPyEndAllowThreads(__tstate);
25935 if (PyErr_Occurred()) SWIG_fail;
25936 }
25937 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
25938 return resultobj;
25939 fail:
25940 return NULL;
25941 }
25942
25943
25944 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25945 PyObject *resultobj = 0;
25946 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
25947 wxSize result;
25948 void *argp1 = 0 ;
25949 int res1 = 0 ;
25950 PyObject *swig_obj[1] ;
25951
25952 if (!args) SWIG_fail;
25953 swig_obj[0] = args;
25954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
25955 if (!SWIG_IsOK(res1)) {
25956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
25957 }
25958 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
25959 {
25960 PyThreadState* __tstate = wxPyBeginAllowThreads();
25961 result = ((wxSizeEvent const *)arg1)->GetSize();
25962 wxPyEndAllowThreads(__tstate);
25963 if (PyErr_Occurred()) SWIG_fail;
25964 }
25965 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
25966 return resultobj;
25967 fail:
25968 return NULL;
25969 }
25970
25971
25972 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25973 PyObject *resultobj = 0;
25974 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
25975 wxRect result;
25976 void *argp1 = 0 ;
25977 int res1 = 0 ;
25978 PyObject *swig_obj[1] ;
25979
25980 if (!args) SWIG_fail;
25981 swig_obj[0] = args;
25982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
25983 if (!SWIG_IsOK(res1)) {
25984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
25985 }
25986 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
25987 {
25988 PyThreadState* __tstate = wxPyBeginAllowThreads();
25989 result = ((wxSizeEvent const *)arg1)->GetRect();
25990 wxPyEndAllowThreads(__tstate);
25991 if (PyErr_Occurred()) SWIG_fail;
25992 }
25993 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
25994 return resultobj;
25995 fail:
25996 return NULL;
25997 }
25998
25999
26000 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26001 PyObject *resultobj = 0;
26002 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26003 wxRect arg2 ;
26004 void *argp1 = 0 ;
26005 int res1 = 0 ;
26006 void *argp2 ;
26007 int res2 = 0 ;
26008 PyObject * obj0 = 0 ;
26009 PyObject * obj1 = 0 ;
26010 char * kwnames[] = {
26011 (char *) "self",(char *) "rect", NULL
26012 };
26013
26014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26016 if (!SWIG_IsOK(res1)) {
26017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26018 }
26019 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26020 {
26021 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
26022 if (!SWIG_IsOK(res2)) {
26023 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26024 }
26025 if (!argp2) {
26026 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26027 } else {
26028 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
26029 arg2 = *temp;
26030 if (SWIG_IsNewObj(res2)) delete temp;
26031 }
26032 }
26033 {
26034 PyThreadState* __tstate = wxPyBeginAllowThreads();
26035 (arg1)->SetRect(arg2);
26036 wxPyEndAllowThreads(__tstate);
26037 if (PyErr_Occurred()) SWIG_fail;
26038 }
26039 resultobj = SWIG_Py_Void();
26040 return resultobj;
26041 fail:
26042 return NULL;
26043 }
26044
26045
26046 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26047 PyObject *resultobj = 0;
26048 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26049 wxSize arg2 ;
26050 void *argp1 = 0 ;
26051 int res1 = 0 ;
26052 void *argp2 ;
26053 int res2 = 0 ;
26054 PyObject * obj0 = 0 ;
26055 PyObject * obj1 = 0 ;
26056 char * kwnames[] = {
26057 (char *) "self",(char *) "size", NULL
26058 };
26059
26060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
26061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26062 if (!SWIG_IsOK(res1)) {
26063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26064 }
26065 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26066 {
26067 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
26068 if (!SWIG_IsOK(res2)) {
26069 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26070 }
26071 if (!argp2) {
26072 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26073 } else {
26074 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
26075 arg2 = *temp;
26076 if (SWIG_IsNewObj(res2)) delete temp;
26077 }
26078 }
26079 {
26080 PyThreadState* __tstate = wxPyBeginAllowThreads();
26081 wxSizeEvent_SetSize(arg1,arg2);
26082 wxPyEndAllowThreads(__tstate);
26083 if (PyErr_Occurred()) SWIG_fail;
26084 }
26085 resultobj = SWIG_Py_Void();
26086 return resultobj;
26087 fail:
26088 return NULL;
26089 }
26090
26091
26092 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26093 PyObject *resultobj = 0;
26094 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26095 wxSize *arg2 = (wxSize *) 0 ;
26096 void *argp1 = 0 ;
26097 int res1 = 0 ;
26098 void *argp2 = 0 ;
26099 int res2 = 0 ;
26100 PyObject *swig_obj[2] ;
26101
26102 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
26103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26104 if (!SWIG_IsOK(res1)) {
26105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26106 }
26107 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26108 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
26109 if (!SWIG_IsOK(res2)) {
26110 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
26111 }
26112 arg2 = reinterpret_cast< wxSize * >(argp2);
26113 if (arg1) (arg1)->m_size = *arg2;
26114
26115 resultobj = SWIG_Py_Void();
26116 return resultobj;
26117 fail:
26118 return NULL;
26119 }
26120
26121
26122 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26123 PyObject *resultobj = 0;
26124 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26125 wxSize *result = 0 ;
26126 void *argp1 = 0 ;
26127 int res1 = 0 ;
26128 PyObject *swig_obj[1] ;
26129
26130 if (!args) SWIG_fail;
26131 swig_obj[0] = args;
26132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26133 if (!SWIG_IsOK(res1)) {
26134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26135 }
26136 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26137 result = (wxSize *)& ((arg1)->m_size);
26138 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
26139 return resultobj;
26140 fail:
26141 return NULL;
26142 }
26143
26144
26145 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26146 PyObject *resultobj = 0;
26147 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26148 wxRect *arg2 = (wxRect *) 0 ;
26149 void *argp1 = 0 ;
26150 int res1 = 0 ;
26151 void *argp2 = 0 ;
26152 int res2 = 0 ;
26153 PyObject *swig_obj[2] ;
26154
26155 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
26156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26157 if (!SWIG_IsOK(res1)) {
26158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26159 }
26160 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26161 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
26162 if (!SWIG_IsOK(res2)) {
26163 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
26164 }
26165 arg2 = reinterpret_cast< wxRect * >(argp2);
26166 if (arg1) (arg1)->m_rect = *arg2;
26167
26168 resultobj = SWIG_Py_Void();
26169 return resultobj;
26170 fail:
26171 return NULL;
26172 }
26173
26174
26175 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26176 PyObject *resultobj = 0;
26177 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26178 wxRect *result = 0 ;
26179 void *argp1 = 0 ;
26180 int res1 = 0 ;
26181 PyObject *swig_obj[1] ;
26182
26183 if (!args) SWIG_fail;
26184 swig_obj[0] = args;
26185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26186 if (!SWIG_IsOK(res1)) {
26187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26188 }
26189 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26190 result = (wxRect *)& ((arg1)->m_rect);
26191 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
26192 return resultobj;
26193 fail:
26194 return NULL;
26195 }
26196
26197
26198 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26199 PyObject *obj;
26200 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26201 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
26202 return SWIG_Py_Void();
26203 }
26204
26205 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26206 return SWIG_Python_InitShadowInstance(args);
26207 }
26208
26209 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26210 PyObject *resultobj = 0;
26211 wxPoint const &arg1_defvalue = wxDefaultPosition ;
26212 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
26213 int arg2 = (int) 0 ;
26214 wxMoveEvent *result = 0 ;
26215 wxPoint temp1 ;
26216 int val2 ;
26217 int ecode2 = 0 ;
26218 PyObject * obj0 = 0 ;
26219 PyObject * obj1 = 0 ;
26220 char * kwnames[] = {
26221 (char *) "pos",(char *) "winid", NULL
26222 };
26223
26224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26225 if (obj0) {
26226 {
26227 arg1 = &temp1;
26228 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
26229 }
26230 }
26231 if (obj1) {
26232 ecode2 = SWIG_AsVal_int(obj1, &val2);
26233 if (!SWIG_IsOK(ecode2)) {
26234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
26235 }
26236 arg2 = static_cast< int >(val2);
26237 }
26238 {
26239 PyThreadState* __tstate = wxPyBeginAllowThreads();
26240 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
26241 wxPyEndAllowThreads(__tstate);
26242 if (PyErr_Occurred()) SWIG_fail;
26243 }
26244 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
26245 return resultobj;
26246 fail:
26247 return NULL;
26248 }
26249
26250
26251 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26252 PyObject *resultobj = 0;
26253 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26254 wxPoint result;
26255 void *argp1 = 0 ;
26256 int res1 = 0 ;
26257 PyObject *swig_obj[1] ;
26258
26259 if (!args) SWIG_fail;
26260 swig_obj[0] = args;
26261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26262 if (!SWIG_IsOK(res1)) {
26263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26264 }
26265 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26266 {
26267 PyThreadState* __tstate = wxPyBeginAllowThreads();
26268 result = ((wxMoveEvent const *)arg1)->GetPosition();
26269 wxPyEndAllowThreads(__tstate);
26270 if (PyErr_Occurred()) SWIG_fail;
26271 }
26272 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
26273 return resultobj;
26274 fail:
26275 return NULL;
26276 }
26277
26278
26279 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26280 PyObject *resultobj = 0;
26281 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26282 wxRect result;
26283 void *argp1 = 0 ;
26284 int res1 = 0 ;
26285 PyObject *swig_obj[1] ;
26286
26287 if (!args) SWIG_fail;
26288 swig_obj[0] = args;
26289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26290 if (!SWIG_IsOK(res1)) {
26291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26292 }
26293 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26294 {
26295 PyThreadState* __tstate = wxPyBeginAllowThreads();
26296 result = ((wxMoveEvent const *)arg1)->GetRect();
26297 wxPyEndAllowThreads(__tstate);
26298 if (PyErr_Occurred()) SWIG_fail;
26299 }
26300 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26301 return resultobj;
26302 fail:
26303 return NULL;
26304 }
26305
26306
26307 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26308 PyObject *resultobj = 0;
26309 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26310 wxRect *arg2 = 0 ;
26311 void *argp1 = 0 ;
26312 int res1 = 0 ;
26313 wxRect temp2 ;
26314 PyObject * obj0 = 0 ;
26315 PyObject * obj1 = 0 ;
26316 char * kwnames[] = {
26317 (char *) "self",(char *) "rect", NULL
26318 };
26319
26320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26322 if (!SWIG_IsOK(res1)) {
26323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26324 }
26325 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26326 {
26327 arg2 = &temp2;
26328 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26329 }
26330 {
26331 PyThreadState* __tstate = wxPyBeginAllowThreads();
26332 (arg1)->SetRect((wxRect const &)*arg2);
26333 wxPyEndAllowThreads(__tstate);
26334 if (PyErr_Occurred()) SWIG_fail;
26335 }
26336 resultobj = SWIG_Py_Void();
26337 return resultobj;
26338 fail:
26339 return NULL;
26340 }
26341
26342
26343 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26344 PyObject *resultobj = 0;
26345 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26346 wxPoint *arg2 = 0 ;
26347 void *argp1 = 0 ;
26348 int res1 = 0 ;
26349 wxPoint temp2 ;
26350 PyObject * obj0 = 0 ;
26351 PyObject * obj1 = 0 ;
26352 char * kwnames[] = {
26353 (char *) "self",(char *) "pos", NULL
26354 };
26355
26356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26358 if (!SWIG_IsOK(res1)) {
26359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26360 }
26361 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26362 {
26363 arg2 = &temp2;
26364 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26365 }
26366 {
26367 PyThreadState* __tstate = wxPyBeginAllowThreads();
26368 (arg1)->SetPosition((wxPoint const &)*arg2);
26369 wxPyEndAllowThreads(__tstate);
26370 if (PyErr_Occurred()) SWIG_fail;
26371 }
26372 resultobj = SWIG_Py_Void();
26373 return resultobj;
26374 fail:
26375 return NULL;
26376 }
26377
26378
26379 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26380 PyObject *obj;
26381 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26382 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
26383 return SWIG_Py_Void();
26384 }
26385
26386 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26387 return SWIG_Python_InitShadowInstance(args);
26388 }
26389
26390 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26391 PyObject *resultobj = 0;
26392 int arg1 = (int) 0 ;
26393 wxPaintEvent *result = 0 ;
26394 int val1 ;
26395 int ecode1 = 0 ;
26396 PyObject * obj0 = 0 ;
26397 char * kwnames[] = {
26398 (char *) "Id", NULL
26399 };
26400
26401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
26402 if (obj0) {
26403 ecode1 = SWIG_AsVal_int(obj0, &val1);
26404 if (!SWIG_IsOK(ecode1)) {
26405 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
26406 }
26407 arg1 = static_cast< int >(val1);
26408 }
26409 {
26410 PyThreadState* __tstate = wxPyBeginAllowThreads();
26411 result = (wxPaintEvent *)new wxPaintEvent(arg1);
26412 wxPyEndAllowThreads(__tstate);
26413 if (PyErr_Occurred()) SWIG_fail;
26414 }
26415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
26416 return resultobj;
26417 fail:
26418 return NULL;
26419 }
26420
26421
26422 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26423 PyObject *obj;
26424 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26425 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
26426 return SWIG_Py_Void();
26427 }
26428
26429 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26430 return SWIG_Python_InitShadowInstance(args);
26431 }
26432
26433 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26434 PyObject *resultobj = 0;
26435 int arg1 = (int) 0 ;
26436 wxNcPaintEvent *result = 0 ;
26437 int val1 ;
26438 int ecode1 = 0 ;
26439 PyObject * obj0 = 0 ;
26440 char * kwnames[] = {
26441 (char *) "winid", NULL
26442 };
26443
26444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
26445 if (obj0) {
26446 ecode1 = SWIG_AsVal_int(obj0, &val1);
26447 if (!SWIG_IsOK(ecode1)) {
26448 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
26449 }
26450 arg1 = static_cast< int >(val1);
26451 }
26452 {
26453 PyThreadState* __tstate = wxPyBeginAllowThreads();
26454 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
26455 wxPyEndAllowThreads(__tstate);
26456 if (PyErr_Occurred()) SWIG_fail;
26457 }
26458 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
26459 return resultobj;
26460 fail:
26461 return NULL;
26462 }
26463
26464
26465 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26466 PyObject *obj;
26467 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26468 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
26469 return SWIG_Py_Void();
26470 }
26471
26472 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26473 return SWIG_Python_InitShadowInstance(args);
26474 }
26475
26476 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26477 PyObject *resultobj = 0;
26478 int arg1 = (int) 0 ;
26479 wxDC *arg2 = (wxDC *) NULL ;
26480 wxEraseEvent *result = 0 ;
26481 int val1 ;
26482 int ecode1 = 0 ;
26483 void *argp2 = 0 ;
26484 int res2 = 0 ;
26485 PyObject * obj0 = 0 ;
26486 PyObject * obj1 = 0 ;
26487 char * kwnames[] = {
26488 (char *) "Id",(char *) "dc", NULL
26489 };
26490
26491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26492 if (obj0) {
26493 ecode1 = SWIG_AsVal_int(obj0, &val1);
26494 if (!SWIG_IsOK(ecode1)) {
26495 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
26496 }
26497 arg1 = static_cast< int >(val1);
26498 }
26499 if (obj1) {
26500 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
26501 if (!SWIG_IsOK(res2)) {
26502 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
26503 }
26504 arg2 = reinterpret_cast< wxDC * >(argp2);
26505 }
26506 {
26507 PyThreadState* __tstate = wxPyBeginAllowThreads();
26508 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
26509 wxPyEndAllowThreads(__tstate);
26510 if (PyErr_Occurred()) SWIG_fail;
26511 }
26512 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
26513 return resultobj;
26514 fail:
26515 return NULL;
26516 }
26517
26518
26519 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26520 PyObject *resultobj = 0;
26521 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
26522 wxDC *result = 0 ;
26523 void *argp1 = 0 ;
26524 int res1 = 0 ;
26525 PyObject *swig_obj[1] ;
26526
26527 if (!args) SWIG_fail;
26528 swig_obj[0] = args;
26529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
26530 if (!SWIG_IsOK(res1)) {
26531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
26532 }
26533 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
26534 {
26535 PyThreadState* __tstate = wxPyBeginAllowThreads();
26536 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
26537 wxPyEndAllowThreads(__tstate);
26538 if (PyErr_Occurred()) SWIG_fail;
26539 }
26540 {
26541 resultobj = wxPyMake_wxObject(result, (bool)0);
26542 }
26543 return resultobj;
26544 fail:
26545 return NULL;
26546 }
26547
26548
26549 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26550 PyObject *obj;
26551 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26552 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
26553 return SWIG_Py_Void();
26554 }
26555
26556 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26557 return SWIG_Python_InitShadowInstance(args);
26558 }
26559
26560 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26561 PyObject *resultobj = 0;
26562 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26563 int arg2 = (int) 0 ;
26564 wxFocusEvent *result = 0 ;
26565 int val1 ;
26566 int ecode1 = 0 ;
26567 int val2 ;
26568 int ecode2 = 0 ;
26569 PyObject * obj0 = 0 ;
26570 PyObject * obj1 = 0 ;
26571 char * kwnames[] = {
26572 (char *) "type",(char *) "winid", NULL
26573 };
26574
26575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26576 if (obj0) {
26577 ecode1 = SWIG_AsVal_int(obj0, &val1);
26578 if (!SWIG_IsOK(ecode1)) {
26579 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26580 }
26581 arg1 = static_cast< wxEventType >(val1);
26582 }
26583 if (obj1) {
26584 ecode2 = SWIG_AsVal_int(obj1, &val2);
26585 if (!SWIG_IsOK(ecode2)) {
26586 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
26587 }
26588 arg2 = static_cast< int >(val2);
26589 }
26590 {
26591 PyThreadState* __tstate = wxPyBeginAllowThreads();
26592 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
26593 wxPyEndAllowThreads(__tstate);
26594 if (PyErr_Occurred()) SWIG_fail;
26595 }
26596 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
26597 return resultobj;
26598 fail:
26599 return NULL;
26600 }
26601
26602
26603 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26604 PyObject *resultobj = 0;
26605 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26606 wxWindow *result = 0 ;
26607 void *argp1 = 0 ;
26608 int res1 = 0 ;
26609 PyObject *swig_obj[1] ;
26610
26611 if (!args) SWIG_fail;
26612 swig_obj[0] = args;
26613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26614 if (!SWIG_IsOK(res1)) {
26615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
26616 }
26617 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26618 {
26619 PyThreadState* __tstate = wxPyBeginAllowThreads();
26620 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
26621 wxPyEndAllowThreads(__tstate);
26622 if (PyErr_Occurred()) SWIG_fail;
26623 }
26624 {
26625 resultobj = wxPyMake_wxObject(result, (bool)0);
26626 }
26627 return resultobj;
26628 fail:
26629 return NULL;
26630 }
26631
26632
26633 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26634 PyObject *resultobj = 0;
26635 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26636 wxWindow *arg2 = (wxWindow *) 0 ;
26637 void *argp1 = 0 ;
26638 int res1 = 0 ;
26639 void *argp2 = 0 ;
26640 int res2 = 0 ;
26641 PyObject * obj0 = 0 ;
26642 PyObject * obj1 = 0 ;
26643 char * kwnames[] = {
26644 (char *) "self",(char *) "win", NULL
26645 };
26646
26647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
26648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26649 if (!SWIG_IsOK(res1)) {
26650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
26651 }
26652 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26653 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26654 if (!SWIG_IsOK(res2)) {
26655 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
26656 }
26657 arg2 = reinterpret_cast< wxWindow * >(argp2);
26658 {
26659 PyThreadState* __tstate = wxPyBeginAllowThreads();
26660 (arg1)->SetWindow(arg2);
26661 wxPyEndAllowThreads(__tstate);
26662 if (PyErr_Occurred()) SWIG_fail;
26663 }
26664 resultobj = SWIG_Py_Void();
26665 return resultobj;
26666 fail:
26667 return NULL;
26668 }
26669
26670
26671 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26672 PyObject *obj;
26673 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26674 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
26675 return SWIG_Py_Void();
26676 }
26677
26678 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26679 return SWIG_Python_InitShadowInstance(args);
26680 }
26681
26682 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26683 PyObject *resultobj = 0;
26684 wxWindow *arg1 = (wxWindow *) NULL ;
26685 wxChildFocusEvent *result = 0 ;
26686 void *argp1 = 0 ;
26687 int res1 = 0 ;
26688 PyObject * obj0 = 0 ;
26689 char * kwnames[] = {
26690 (char *) "win", NULL
26691 };
26692
26693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
26694 if (obj0) {
26695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26696 if (!SWIG_IsOK(res1)) {
26697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26698 }
26699 arg1 = reinterpret_cast< wxWindow * >(argp1);
26700 }
26701 {
26702 PyThreadState* __tstate = wxPyBeginAllowThreads();
26703 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
26704 wxPyEndAllowThreads(__tstate);
26705 if (PyErr_Occurred()) SWIG_fail;
26706 }
26707 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
26708 return resultobj;
26709 fail:
26710 return NULL;
26711 }
26712
26713
26714 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26715 PyObject *resultobj = 0;
26716 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
26717 wxWindow *result = 0 ;
26718 void *argp1 = 0 ;
26719 int res1 = 0 ;
26720 PyObject *swig_obj[1] ;
26721
26722 if (!args) SWIG_fail;
26723 swig_obj[0] = args;
26724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
26725 if (!SWIG_IsOK(res1)) {
26726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
26727 }
26728 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
26729 {
26730 PyThreadState* __tstate = wxPyBeginAllowThreads();
26731 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
26732 wxPyEndAllowThreads(__tstate);
26733 if (PyErr_Occurred()) SWIG_fail;
26734 }
26735 {
26736 resultobj = wxPyMake_wxObject(result, (bool)0);
26737 }
26738 return resultobj;
26739 fail:
26740 return NULL;
26741 }
26742
26743
26744 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26745 PyObject *obj;
26746 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26747 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
26748 return SWIG_Py_Void();
26749 }
26750
26751 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26752 return SWIG_Python_InitShadowInstance(args);
26753 }
26754
26755 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26756 PyObject *resultobj = 0;
26757 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26758 bool arg2 = (bool) true ;
26759 int arg3 = (int) 0 ;
26760 wxActivateEvent *result = 0 ;
26761 int val1 ;
26762 int ecode1 = 0 ;
26763 bool val2 ;
26764 int ecode2 = 0 ;
26765 int val3 ;
26766 int ecode3 = 0 ;
26767 PyObject * obj0 = 0 ;
26768 PyObject * obj1 = 0 ;
26769 PyObject * obj2 = 0 ;
26770 char * kwnames[] = {
26771 (char *) "type",(char *) "active",(char *) "Id", NULL
26772 };
26773
26774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26775 if (obj0) {
26776 ecode1 = SWIG_AsVal_int(obj0, &val1);
26777 if (!SWIG_IsOK(ecode1)) {
26778 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26779 }
26780 arg1 = static_cast< wxEventType >(val1);
26781 }
26782 if (obj1) {
26783 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26784 if (!SWIG_IsOK(ecode2)) {
26785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
26786 }
26787 arg2 = static_cast< bool >(val2);
26788 }
26789 if (obj2) {
26790 ecode3 = SWIG_AsVal_int(obj2, &val3);
26791 if (!SWIG_IsOK(ecode3)) {
26792 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
26793 }
26794 arg3 = static_cast< int >(val3);
26795 }
26796 {
26797 PyThreadState* __tstate = wxPyBeginAllowThreads();
26798 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
26799 wxPyEndAllowThreads(__tstate);
26800 if (PyErr_Occurred()) SWIG_fail;
26801 }
26802 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
26803 return resultobj;
26804 fail:
26805 return NULL;
26806 }
26807
26808
26809 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26810 PyObject *resultobj = 0;
26811 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
26812 bool result;
26813 void *argp1 = 0 ;
26814 int res1 = 0 ;
26815 PyObject *swig_obj[1] ;
26816
26817 if (!args) SWIG_fail;
26818 swig_obj[0] = args;
26819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
26820 if (!SWIG_IsOK(res1)) {
26821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
26822 }
26823 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
26824 {
26825 PyThreadState* __tstate = wxPyBeginAllowThreads();
26826 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
26827 wxPyEndAllowThreads(__tstate);
26828 if (PyErr_Occurred()) SWIG_fail;
26829 }
26830 {
26831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26832 }
26833 return resultobj;
26834 fail:
26835 return NULL;
26836 }
26837
26838
26839 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26840 PyObject *obj;
26841 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26842 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
26843 return SWIG_Py_Void();
26844 }
26845
26846 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26847 return SWIG_Python_InitShadowInstance(args);
26848 }
26849
26850 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26851 PyObject *resultobj = 0;
26852 int arg1 = (int) 0 ;
26853 wxInitDialogEvent *result = 0 ;
26854 int val1 ;
26855 int ecode1 = 0 ;
26856 PyObject * obj0 = 0 ;
26857 char * kwnames[] = {
26858 (char *) "Id", NULL
26859 };
26860
26861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
26862 if (obj0) {
26863 ecode1 = SWIG_AsVal_int(obj0, &val1);
26864 if (!SWIG_IsOK(ecode1)) {
26865 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
26866 }
26867 arg1 = static_cast< int >(val1);
26868 }
26869 {
26870 PyThreadState* __tstate = wxPyBeginAllowThreads();
26871 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
26872 wxPyEndAllowThreads(__tstate);
26873 if (PyErr_Occurred()) SWIG_fail;
26874 }
26875 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
26876 return resultobj;
26877 fail:
26878 return NULL;
26879 }
26880
26881
26882 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26883 PyObject *obj;
26884 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26885 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
26886 return SWIG_Py_Void();
26887 }
26888
26889 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26890 return SWIG_Python_InitShadowInstance(args);
26891 }
26892
26893 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26894 PyObject *resultobj = 0;
26895 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26896 int arg2 = (int) 0 ;
26897 wxMenu *arg3 = (wxMenu *) NULL ;
26898 wxMenuEvent *result = 0 ;
26899 int val1 ;
26900 int ecode1 = 0 ;
26901 int val2 ;
26902 int ecode2 = 0 ;
26903 void *argp3 = 0 ;
26904 int res3 = 0 ;
26905 PyObject * obj0 = 0 ;
26906 PyObject * obj1 = 0 ;
26907 PyObject * obj2 = 0 ;
26908 char * kwnames[] = {
26909 (char *) "type",(char *) "winid",(char *) "menu", NULL
26910 };
26911
26912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26913 if (obj0) {
26914 ecode1 = SWIG_AsVal_int(obj0, &val1);
26915 if (!SWIG_IsOK(ecode1)) {
26916 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26917 }
26918 arg1 = static_cast< wxEventType >(val1);
26919 }
26920 if (obj1) {
26921 ecode2 = SWIG_AsVal_int(obj1, &val2);
26922 if (!SWIG_IsOK(ecode2)) {
26923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
26924 }
26925 arg2 = static_cast< int >(val2);
26926 }
26927 if (obj2) {
26928 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
26929 if (!SWIG_IsOK(res3)) {
26930 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
26931 }
26932 arg3 = reinterpret_cast< wxMenu * >(argp3);
26933 }
26934 {
26935 PyThreadState* __tstate = wxPyBeginAllowThreads();
26936 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
26937 wxPyEndAllowThreads(__tstate);
26938 if (PyErr_Occurred()) SWIG_fail;
26939 }
26940 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
26941 return resultobj;
26942 fail:
26943 return NULL;
26944 }
26945
26946
26947 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26948 PyObject *resultobj = 0;
26949 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
26950 int result;
26951 void *argp1 = 0 ;
26952 int res1 = 0 ;
26953 PyObject *swig_obj[1] ;
26954
26955 if (!args) SWIG_fail;
26956 swig_obj[0] = args;
26957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
26958 if (!SWIG_IsOK(res1)) {
26959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
26960 }
26961 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
26962 {
26963 PyThreadState* __tstate = wxPyBeginAllowThreads();
26964 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
26965 wxPyEndAllowThreads(__tstate);
26966 if (PyErr_Occurred()) SWIG_fail;
26967 }
26968 resultobj = SWIG_From_int(static_cast< int >(result));
26969 return resultobj;
26970 fail:
26971 return NULL;
26972 }
26973
26974
26975 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26976 PyObject *resultobj = 0;
26977 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
26978 bool result;
26979 void *argp1 = 0 ;
26980 int res1 = 0 ;
26981 PyObject *swig_obj[1] ;
26982
26983 if (!args) SWIG_fail;
26984 swig_obj[0] = args;
26985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
26986 if (!SWIG_IsOK(res1)) {
26987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
26988 }
26989 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
26990 {
26991 PyThreadState* __tstate = wxPyBeginAllowThreads();
26992 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
26993 wxPyEndAllowThreads(__tstate);
26994 if (PyErr_Occurred()) SWIG_fail;
26995 }
26996 {
26997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26998 }
26999 return resultobj;
27000 fail:
27001 return NULL;
27002 }
27003
27004
27005 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27006 PyObject *resultobj = 0;
27007 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27008 wxMenu *result = 0 ;
27009 void *argp1 = 0 ;
27010 int res1 = 0 ;
27011 PyObject *swig_obj[1] ;
27012
27013 if (!args) SWIG_fail;
27014 swig_obj[0] = args;
27015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27016 if (!SWIG_IsOK(res1)) {
27017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27018 }
27019 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27020 {
27021 PyThreadState* __tstate = wxPyBeginAllowThreads();
27022 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
27023 wxPyEndAllowThreads(__tstate);
27024 if (PyErr_Occurred()) SWIG_fail;
27025 }
27026 {
27027 resultobj = wxPyMake_wxObject(result, (bool)0);
27028 }
27029 return resultobj;
27030 fail:
27031 return NULL;
27032 }
27033
27034
27035 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27036 PyObject *obj;
27037 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27038 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
27039 return SWIG_Py_Void();
27040 }
27041
27042 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27043 return SWIG_Python_InitShadowInstance(args);
27044 }
27045
27046 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27047 PyObject *resultobj = 0;
27048 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27049 int arg2 = (int) 0 ;
27050 wxCloseEvent *result = 0 ;
27051 int val1 ;
27052 int ecode1 = 0 ;
27053 int val2 ;
27054 int ecode2 = 0 ;
27055 PyObject * obj0 = 0 ;
27056 PyObject * obj1 = 0 ;
27057 char * kwnames[] = {
27058 (char *) "type",(char *) "winid", NULL
27059 };
27060
27061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27062 if (obj0) {
27063 ecode1 = SWIG_AsVal_int(obj0, &val1);
27064 if (!SWIG_IsOK(ecode1)) {
27065 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27066 }
27067 arg1 = static_cast< wxEventType >(val1);
27068 }
27069 if (obj1) {
27070 ecode2 = SWIG_AsVal_int(obj1, &val2);
27071 if (!SWIG_IsOK(ecode2)) {
27072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
27073 }
27074 arg2 = static_cast< int >(val2);
27075 }
27076 {
27077 PyThreadState* __tstate = wxPyBeginAllowThreads();
27078 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
27079 wxPyEndAllowThreads(__tstate);
27080 if (PyErr_Occurred()) SWIG_fail;
27081 }
27082 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
27083 return resultobj;
27084 fail:
27085 return NULL;
27086 }
27087
27088
27089 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27090 PyObject *resultobj = 0;
27091 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27092 bool arg2 ;
27093 void *argp1 = 0 ;
27094 int res1 = 0 ;
27095 bool val2 ;
27096 int ecode2 = 0 ;
27097 PyObject * obj0 = 0 ;
27098 PyObject * obj1 = 0 ;
27099 char * kwnames[] = {
27100 (char *) "self",(char *) "logOff", NULL
27101 };
27102
27103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
27104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27105 if (!SWIG_IsOK(res1)) {
27106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27107 }
27108 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27109 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27110 if (!SWIG_IsOK(ecode2)) {
27111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
27112 }
27113 arg2 = static_cast< bool >(val2);
27114 {
27115 PyThreadState* __tstate = wxPyBeginAllowThreads();
27116 (arg1)->SetLoggingOff(arg2);
27117 wxPyEndAllowThreads(__tstate);
27118 if (PyErr_Occurred()) SWIG_fail;
27119 }
27120 resultobj = SWIG_Py_Void();
27121 return resultobj;
27122 fail:
27123 return NULL;
27124 }
27125
27126
27127 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27128 PyObject *resultobj = 0;
27129 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27130 bool result;
27131 void *argp1 = 0 ;
27132 int res1 = 0 ;
27133 PyObject *swig_obj[1] ;
27134
27135 if (!args) SWIG_fail;
27136 swig_obj[0] = args;
27137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27138 if (!SWIG_IsOK(res1)) {
27139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27140 }
27141 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27142 {
27143 PyThreadState* __tstate = wxPyBeginAllowThreads();
27144 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
27145 wxPyEndAllowThreads(__tstate);
27146 if (PyErr_Occurred()) SWIG_fail;
27147 }
27148 {
27149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27150 }
27151 return resultobj;
27152 fail:
27153 return NULL;
27154 }
27155
27156
27157 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27158 PyObject *resultobj = 0;
27159 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27160 bool arg2 = (bool) true ;
27161 void *argp1 = 0 ;
27162 int res1 = 0 ;
27163 bool val2 ;
27164 int ecode2 = 0 ;
27165 PyObject * obj0 = 0 ;
27166 PyObject * obj1 = 0 ;
27167 char * kwnames[] = {
27168 (char *) "self",(char *) "veto", NULL
27169 };
27170
27171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
27172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27173 if (!SWIG_IsOK(res1)) {
27174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27175 }
27176 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27177 if (obj1) {
27178 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27179 if (!SWIG_IsOK(ecode2)) {
27180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
27181 }
27182 arg2 = static_cast< bool >(val2);
27183 }
27184 {
27185 PyThreadState* __tstate = wxPyBeginAllowThreads();
27186 (arg1)->Veto(arg2);
27187 wxPyEndAllowThreads(__tstate);
27188 if (PyErr_Occurred()) SWIG_fail;
27189 }
27190 resultobj = SWIG_Py_Void();
27191 return resultobj;
27192 fail:
27193 return NULL;
27194 }
27195
27196
27197 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27198 PyObject *resultobj = 0;
27199 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27200 bool result;
27201 void *argp1 = 0 ;
27202 int res1 = 0 ;
27203 PyObject *swig_obj[1] ;
27204
27205 if (!args) SWIG_fail;
27206 swig_obj[0] = args;
27207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27208 if (!SWIG_IsOK(res1)) {
27209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27210 }
27211 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27212 {
27213 PyThreadState* __tstate = wxPyBeginAllowThreads();
27214 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
27215 wxPyEndAllowThreads(__tstate);
27216 if (PyErr_Occurred()) SWIG_fail;
27217 }
27218 {
27219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27220 }
27221 return resultobj;
27222 fail:
27223 return NULL;
27224 }
27225
27226
27227 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27228 PyObject *resultobj = 0;
27229 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27230 bool arg2 ;
27231 void *argp1 = 0 ;
27232 int res1 = 0 ;
27233 bool val2 ;
27234 int ecode2 = 0 ;
27235 PyObject * obj0 = 0 ;
27236 PyObject * obj1 = 0 ;
27237 char * kwnames[] = {
27238 (char *) "self",(char *) "canVeto", NULL
27239 };
27240
27241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
27242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27243 if (!SWIG_IsOK(res1)) {
27244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27245 }
27246 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27247 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27248 if (!SWIG_IsOK(ecode2)) {
27249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
27250 }
27251 arg2 = static_cast< bool >(val2);
27252 {
27253 PyThreadState* __tstate = wxPyBeginAllowThreads();
27254 (arg1)->SetCanVeto(arg2);
27255 wxPyEndAllowThreads(__tstate);
27256 if (PyErr_Occurred()) SWIG_fail;
27257 }
27258 resultobj = SWIG_Py_Void();
27259 return resultobj;
27260 fail:
27261 return NULL;
27262 }
27263
27264
27265 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27266 PyObject *resultobj = 0;
27267 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27268 bool result;
27269 void *argp1 = 0 ;
27270 int res1 = 0 ;
27271 PyObject *swig_obj[1] ;
27272
27273 if (!args) SWIG_fail;
27274 swig_obj[0] = args;
27275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27276 if (!SWIG_IsOK(res1)) {
27277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27278 }
27279 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27280 {
27281 PyThreadState* __tstate = wxPyBeginAllowThreads();
27282 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
27283 wxPyEndAllowThreads(__tstate);
27284 if (PyErr_Occurred()) SWIG_fail;
27285 }
27286 {
27287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27288 }
27289 return resultobj;
27290 fail:
27291 return NULL;
27292 }
27293
27294
27295 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27296 PyObject *obj;
27297 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27298 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
27299 return SWIG_Py_Void();
27300 }
27301
27302 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27303 return SWIG_Python_InitShadowInstance(args);
27304 }
27305
27306 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27307 PyObject *resultobj = 0;
27308 int arg1 = (int) 0 ;
27309 bool arg2 = (bool) false ;
27310 wxShowEvent *result = 0 ;
27311 int val1 ;
27312 int ecode1 = 0 ;
27313 bool val2 ;
27314 int ecode2 = 0 ;
27315 PyObject * obj0 = 0 ;
27316 PyObject * obj1 = 0 ;
27317 char * kwnames[] = {
27318 (char *) "winid",(char *) "show", NULL
27319 };
27320
27321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27322 if (obj0) {
27323 ecode1 = SWIG_AsVal_int(obj0, &val1);
27324 if (!SWIG_IsOK(ecode1)) {
27325 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
27326 }
27327 arg1 = static_cast< int >(val1);
27328 }
27329 if (obj1) {
27330 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27331 if (!SWIG_IsOK(ecode2)) {
27332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
27333 }
27334 arg2 = static_cast< bool >(val2);
27335 }
27336 {
27337 PyThreadState* __tstate = wxPyBeginAllowThreads();
27338 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
27339 wxPyEndAllowThreads(__tstate);
27340 if (PyErr_Occurred()) SWIG_fail;
27341 }
27342 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
27343 return resultobj;
27344 fail:
27345 return NULL;
27346 }
27347
27348
27349 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27350 PyObject *resultobj = 0;
27351 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27352 bool arg2 ;
27353 void *argp1 = 0 ;
27354 int res1 = 0 ;
27355 bool val2 ;
27356 int ecode2 = 0 ;
27357 PyObject * obj0 = 0 ;
27358 PyObject * obj1 = 0 ;
27359 char * kwnames[] = {
27360 (char *) "self",(char *) "show", NULL
27361 };
27362
27363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
27364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27365 if (!SWIG_IsOK(res1)) {
27366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
27367 }
27368 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27369 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27370 if (!SWIG_IsOK(ecode2)) {
27371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
27372 }
27373 arg2 = static_cast< bool >(val2);
27374 {
27375 PyThreadState* __tstate = wxPyBeginAllowThreads();
27376 (arg1)->SetShow(arg2);
27377 wxPyEndAllowThreads(__tstate);
27378 if (PyErr_Occurred()) SWIG_fail;
27379 }
27380 resultobj = SWIG_Py_Void();
27381 return resultobj;
27382 fail:
27383 return NULL;
27384 }
27385
27386
27387 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27388 PyObject *resultobj = 0;
27389 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27390 bool result;
27391 void *argp1 = 0 ;
27392 int res1 = 0 ;
27393 PyObject *swig_obj[1] ;
27394
27395 if (!args) SWIG_fail;
27396 swig_obj[0] = args;
27397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27398 if (!SWIG_IsOK(res1)) {
27399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
27400 }
27401 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27402 {
27403 PyThreadState* __tstate = wxPyBeginAllowThreads();
27404 result = (bool)((wxShowEvent const *)arg1)->GetShow();
27405 wxPyEndAllowThreads(__tstate);
27406 if (PyErr_Occurred()) SWIG_fail;
27407 }
27408 {
27409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27410 }
27411 return resultobj;
27412 fail:
27413 return NULL;
27414 }
27415
27416
27417 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27418 PyObject *obj;
27419 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27420 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
27421 return SWIG_Py_Void();
27422 }
27423
27424 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27425 return SWIG_Python_InitShadowInstance(args);
27426 }
27427
27428 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27429 PyObject *resultobj = 0;
27430 int arg1 = (int) 0 ;
27431 bool arg2 = (bool) true ;
27432 wxIconizeEvent *result = 0 ;
27433 int val1 ;
27434 int ecode1 = 0 ;
27435 bool val2 ;
27436 int ecode2 = 0 ;
27437 PyObject * obj0 = 0 ;
27438 PyObject * obj1 = 0 ;
27439 char * kwnames[] = {
27440 (char *) "id",(char *) "iconized", NULL
27441 };
27442
27443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27444 if (obj0) {
27445 ecode1 = SWIG_AsVal_int(obj0, &val1);
27446 if (!SWIG_IsOK(ecode1)) {
27447 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
27448 }
27449 arg1 = static_cast< int >(val1);
27450 }
27451 if (obj1) {
27452 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27453 if (!SWIG_IsOK(ecode2)) {
27454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
27455 }
27456 arg2 = static_cast< bool >(val2);
27457 }
27458 {
27459 PyThreadState* __tstate = wxPyBeginAllowThreads();
27460 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
27461 wxPyEndAllowThreads(__tstate);
27462 if (PyErr_Occurred()) SWIG_fail;
27463 }
27464 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
27465 return resultobj;
27466 fail:
27467 return NULL;
27468 }
27469
27470
27471 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27472 PyObject *resultobj = 0;
27473 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
27474 bool result;
27475 void *argp1 = 0 ;
27476 int res1 = 0 ;
27477 PyObject *swig_obj[1] ;
27478
27479 if (!args) SWIG_fail;
27480 swig_obj[0] = args;
27481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
27482 if (!SWIG_IsOK(res1)) {
27483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
27484 }
27485 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
27486 {
27487 PyThreadState* __tstate = wxPyBeginAllowThreads();
27488 result = (bool)(arg1)->Iconized();
27489 wxPyEndAllowThreads(__tstate);
27490 if (PyErr_Occurred()) SWIG_fail;
27491 }
27492 {
27493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27494 }
27495 return resultobj;
27496 fail:
27497 return NULL;
27498 }
27499
27500
27501 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27502 PyObject *obj;
27503 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27504 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
27505 return SWIG_Py_Void();
27506 }
27507
27508 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27509 return SWIG_Python_InitShadowInstance(args);
27510 }
27511
27512 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27513 PyObject *resultobj = 0;
27514 int arg1 = (int) 0 ;
27515 wxMaximizeEvent *result = 0 ;
27516 int val1 ;
27517 int ecode1 = 0 ;
27518 PyObject * obj0 = 0 ;
27519 char * kwnames[] = {
27520 (char *) "id", NULL
27521 };
27522
27523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
27524 if (obj0) {
27525 ecode1 = SWIG_AsVal_int(obj0, &val1);
27526 if (!SWIG_IsOK(ecode1)) {
27527 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
27528 }
27529 arg1 = static_cast< int >(val1);
27530 }
27531 {
27532 PyThreadState* __tstate = wxPyBeginAllowThreads();
27533 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
27534 wxPyEndAllowThreads(__tstate);
27535 if (PyErr_Occurred()) SWIG_fail;
27536 }
27537 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
27538 return resultobj;
27539 fail:
27540 return NULL;
27541 }
27542
27543
27544 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27545 PyObject *obj;
27546 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27547 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
27548 return SWIG_Py_Void();
27549 }
27550
27551 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27552 return SWIG_Python_InitShadowInstance(args);
27553 }
27554
27555 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27556 PyObject *resultobj = 0;
27557 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27558 wxPoint result;
27559 void *argp1 = 0 ;
27560 int res1 = 0 ;
27561 PyObject *swig_obj[1] ;
27562
27563 if (!args) SWIG_fail;
27564 swig_obj[0] = args;
27565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27566 if (!SWIG_IsOK(res1)) {
27567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27568 }
27569 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27570 {
27571 PyThreadState* __tstate = wxPyBeginAllowThreads();
27572 result = (arg1)->GetPosition();
27573 wxPyEndAllowThreads(__tstate);
27574 if (PyErr_Occurred()) SWIG_fail;
27575 }
27576 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
27577 return resultobj;
27578 fail:
27579 return NULL;
27580 }
27581
27582
27583 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27584 PyObject *resultobj = 0;
27585 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27586 int result;
27587 void *argp1 = 0 ;
27588 int res1 = 0 ;
27589 PyObject *swig_obj[1] ;
27590
27591 if (!args) SWIG_fail;
27592 swig_obj[0] = args;
27593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27594 if (!SWIG_IsOK(res1)) {
27595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27596 }
27597 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27598 {
27599 PyThreadState* __tstate = wxPyBeginAllowThreads();
27600 result = (int)(arg1)->GetNumberOfFiles();
27601 wxPyEndAllowThreads(__tstate);
27602 if (PyErr_Occurred()) SWIG_fail;
27603 }
27604 resultobj = SWIG_From_int(static_cast< int >(result));
27605 return resultobj;
27606 fail:
27607 return NULL;
27608 }
27609
27610
27611 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27612 PyObject *resultobj = 0;
27613 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27614 PyObject *result = 0 ;
27615 void *argp1 = 0 ;
27616 int res1 = 0 ;
27617 PyObject *swig_obj[1] ;
27618
27619 if (!args) SWIG_fail;
27620 swig_obj[0] = args;
27621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27622 if (!SWIG_IsOK(res1)) {
27623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27624 }
27625 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27626 {
27627 PyThreadState* __tstate = wxPyBeginAllowThreads();
27628 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
27629 wxPyEndAllowThreads(__tstate);
27630 if (PyErr_Occurred()) SWIG_fail;
27631 }
27632 resultobj = result;
27633 return resultobj;
27634 fail:
27635 return NULL;
27636 }
27637
27638
27639 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27640 PyObject *obj;
27641 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27642 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
27643 return SWIG_Py_Void();
27644 }
27645
27646 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27647 PyObject *resultobj = 0;
27648 int arg1 = (int) 0 ;
27649 wxUpdateUIEvent *result = 0 ;
27650 int val1 ;
27651 int ecode1 = 0 ;
27652 PyObject * obj0 = 0 ;
27653 char * kwnames[] = {
27654 (char *) "commandId", NULL
27655 };
27656
27657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
27658 if (obj0) {
27659 ecode1 = SWIG_AsVal_int(obj0, &val1);
27660 if (!SWIG_IsOK(ecode1)) {
27661 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
27662 }
27663 arg1 = static_cast< int >(val1);
27664 }
27665 {
27666 PyThreadState* __tstate = wxPyBeginAllowThreads();
27667 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
27668 wxPyEndAllowThreads(__tstate);
27669 if (PyErr_Occurred()) SWIG_fail;
27670 }
27671 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
27672 return resultobj;
27673 fail:
27674 return NULL;
27675 }
27676
27677
27678 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27679 PyObject *resultobj = 0;
27680 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27681 bool result;
27682 void *argp1 = 0 ;
27683 int res1 = 0 ;
27684 PyObject *swig_obj[1] ;
27685
27686 if (!args) SWIG_fail;
27687 swig_obj[0] = args;
27688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27689 if (!SWIG_IsOK(res1)) {
27690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27691 }
27692 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27693 {
27694 PyThreadState* __tstate = wxPyBeginAllowThreads();
27695 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
27696 wxPyEndAllowThreads(__tstate);
27697 if (PyErr_Occurred()) SWIG_fail;
27698 }
27699 {
27700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27701 }
27702 return resultobj;
27703 fail:
27704 return NULL;
27705 }
27706
27707
27708 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27709 PyObject *resultobj = 0;
27710 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27711 bool result;
27712 void *argp1 = 0 ;
27713 int res1 = 0 ;
27714 PyObject *swig_obj[1] ;
27715
27716 if (!args) SWIG_fail;
27717 swig_obj[0] = args;
27718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27719 if (!SWIG_IsOK(res1)) {
27720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27721 }
27722 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27723 {
27724 PyThreadState* __tstate = wxPyBeginAllowThreads();
27725 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
27726 wxPyEndAllowThreads(__tstate);
27727 if (PyErr_Occurred()) SWIG_fail;
27728 }
27729 {
27730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27731 }
27732 return resultobj;
27733 fail:
27734 return NULL;
27735 }
27736
27737
27738 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27739 PyObject *resultobj = 0;
27740 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27741 bool result;
27742 void *argp1 = 0 ;
27743 int res1 = 0 ;
27744 PyObject *swig_obj[1] ;
27745
27746 if (!args) SWIG_fail;
27747 swig_obj[0] = args;
27748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27749 if (!SWIG_IsOK(res1)) {
27750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27751 }
27752 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27753 {
27754 PyThreadState* __tstate = wxPyBeginAllowThreads();
27755 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
27756 wxPyEndAllowThreads(__tstate);
27757 if (PyErr_Occurred()) SWIG_fail;
27758 }
27759 {
27760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27761 }
27762 return resultobj;
27763 fail:
27764 return NULL;
27765 }
27766
27767
27768 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27769 PyObject *resultobj = 0;
27770 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27771 wxString result;
27772 void *argp1 = 0 ;
27773 int res1 = 0 ;
27774 PyObject *swig_obj[1] ;
27775
27776 if (!args) SWIG_fail;
27777 swig_obj[0] = args;
27778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27779 if (!SWIG_IsOK(res1)) {
27780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27781 }
27782 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27783 {
27784 PyThreadState* __tstate = wxPyBeginAllowThreads();
27785 result = ((wxUpdateUIEvent const *)arg1)->GetText();
27786 wxPyEndAllowThreads(__tstate);
27787 if (PyErr_Occurred()) SWIG_fail;
27788 }
27789 {
27790 #if wxUSE_UNICODE
27791 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27792 #else
27793 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27794 #endif
27795 }
27796 return resultobj;
27797 fail:
27798 return NULL;
27799 }
27800
27801
27802 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27803 PyObject *resultobj = 0;
27804 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27805 bool result;
27806 void *argp1 = 0 ;
27807 int res1 = 0 ;
27808 PyObject *swig_obj[1] ;
27809
27810 if (!args) SWIG_fail;
27811 swig_obj[0] = args;
27812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27813 if (!SWIG_IsOK(res1)) {
27814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27815 }
27816 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27817 {
27818 PyThreadState* __tstate = wxPyBeginAllowThreads();
27819 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
27820 wxPyEndAllowThreads(__tstate);
27821 if (PyErr_Occurred()) SWIG_fail;
27822 }
27823 {
27824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27825 }
27826 return resultobj;
27827 fail:
27828 return NULL;
27829 }
27830
27831
27832 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27833 PyObject *resultobj = 0;
27834 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27835 bool result;
27836 void *argp1 = 0 ;
27837 int res1 = 0 ;
27838 PyObject *swig_obj[1] ;
27839
27840 if (!args) SWIG_fail;
27841 swig_obj[0] = args;
27842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27843 if (!SWIG_IsOK(res1)) {
27844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27845 }
27846 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27847 {
27848 PyThreadState* __tstate = wxPyBeginAllowThreads();
27849 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
27850 wxPyEndAllowThreads(__tstate);
27851 if (PyErr_Occurred()) SWIG_fail;
27852 }
27853 {
27854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27855 }
27856 return resultobj;
27857 fail:
27858 return NULL;
27859 }
27860
27861
27862 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27863 PyObject *resultobj = 0;
27864 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27865 bool result;
27866 void *argp1 = 0 ;
27867 int res1 = 0 ;
27868 PyObject *swig_obj[1] ;
27869
27870 if (!args) SWIG_fail;
27871 swig_obj[0] = args;
27872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27873 if (!SWIG_IsOK(res1)) {
27874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27875 }
27876 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27877 {
27878 PyThreadState* __tstate = wxPyBeginAllowThreads();
27879 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
27880 wxPyEndAllowThreads(__tstate);
27881 if (PyErr_Occurred()) SWIG_fail;
27882 }
27883 {
27884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27885 }
27886 return resultobj;
27887 fail:
27888 return NULL;
27889 }
27890
27891
27892 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27893 PyObject *resultobj = 0;
27894 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27895 bool result;
27896 void *argp1 = 0 ;
27897 int res1 = 0 ;
27898 PyObject *swig_obj[1] ;
27899
27900 if (!args) SWIG_fail;
27901 swig_obj[0] = args;
27902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27903 if (!SWIG_IsOK(res1)) {
27904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27905 }
27906 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27907 {
27908 PyThreadState* __tstate = wxPyBeginAllowThreads();
27909 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
27910 wxPyEndAllowThreads(__tstate);
27911 if (PyErr_Occurred()) SWIG_fail;
27912 }
27913 {
27914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27915 }
27916 return resultobj;
27917 fail:
27918 return NULL;
27919 }
27920
27921
27922 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27923 PyObject *resultobj = 0;
27924 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27925 bool arg2 ;
27926 void *argp1 = 0 ;
27927 int res1 = 0 ;
27928 bool val2 ;
27929 int ecode2 = 0 ;
27930 PyObject * obj0 = 0 ;
27931 PyObject * obj1 = 0 ;
27932 char * kwnames[] = {
27933 (char *) "self",(char *) "check", NULL
27934 };
27935
27936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
27937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27938 if (!SWIG_IsOK(res1)) {
27939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
27940 }
27941 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27942 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27943 if (!SWIG_IsOK(ecode2)) {
27944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
27945 }
27946 arg2 = static_cast< bool >(val2);
27947 {
27948 PyThreadState* __tstate = wxPyBeginAllowThreads();
27949 (arg1)->Check(arg2);
27950 wxPyEndAllowThreads(__tstate);
27951 if (PyErr_Occurred()) SWIG_fail;
27952 }
27953 resultobj = SWIG_Py_Void();
27954 return resultobj;
27955 fail:
27956 return NULL;
27957 }
27958
27959
27960 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27961 PyObject *resultobj = 0;
27962 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27963 bool arg2 ;
27964 void *argp1 = 0 ;
27965 int res1 = 0 ;
27966 bool val2 ;
27967 int ecode2 = 0 ;
27968 PyObject * obj0 = 0 ;
27969 PyObject * obj1 = 0 ;
27970 char * kwnames[] = {
27971 (char *) "self",(char *) "enable", NULL
27972 };
27973
27974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
27975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27976 if (!SWIG_IsOK(res1)) {
27977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
27978 }
27979 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27980 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27981 if (!SWIG_IsOK(ecode2)) {
27982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
27983 }
27984 arg2 = static_cast< bool >(val2);
27985 {
27986 PyThreadState* __tstate = wxPyBeginAllowThreads();
27987 (arg1)->Enable(arg2);
27988 wxPyEndAllowThreads(__tstate);
27989 if (PyErr_Occurred()) SWIG_fail;
27990 }
27991 resultobj = SWIG_Py_Void();
27992 return resultobj;
27993 fail:
27994 return NULL;
27995 }
27996
27997
27998 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27999 PyObject *resultobj = 0;
28000 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28001 bool arg2 ;
28002 void *argp1 = 0 ;
28003 int res1 = 0 ;
28004 bool val2 ;
28005 int ecode2 = 0 ;
28006 PyObject * obj0 = 0 ;
28007 PyObject * obj1 = 0 ;
28008 char * kwnames[] = {
28009 (char *) "self",(char *) "show", NULL
28010 };
28011
28012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
28013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28014 if (!SWIG_IsOK(res1)) {
28015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28016 }
28017 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28018 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28019 if (!SWIG_IsOK(ecode2)) {
28020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
28021 }
28022 arg2 = static_cast< bool >(val2);
28023 {
28024 PyThreadState* __tstate = wxPyBeginAllowThreads();
28025 (arg1)->Show(arg2);
28026 wxPyEndAllowThreads(__tstate);
28027 if (PyErr_Occurred()) SWIG_fail;
28028 }
28029 resultobj = SWIG_Py_Void();
28030 return resultobj;
28031 fail:
28032 return NULL;
28033 }
28034
28035
28036 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28037 PyObject *resultobj = 0;
28038 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28039 wxString *arg2 = 0 ;
28040 void *argp1 = 0 ;
28041 int res1 = 0 ;
28042 bool temp2 = false ;
28043 PyObject * obj0 = 0 ;
28044 PyObject * obj1 = 0 ;
28045 char * kwnames[] = {
28046 (char *) "self",(char *) "text", NULL
28047 };
28048
28049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
28050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28051 if (!SWIG_IsOK(res1)) {
28052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28053 }
28054 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28055 {
28056 arg2 = wxString_in_helper(obj1);
28057 if (arg2 == NULL) SWIG_fail;
28058 temp2 = true;
28059 }
28060 {
28061 PyThreadState* __tstate = wxPyBeginAllowThreads();
28062 (arg1)->SetText((wxString const &)*arg2);
28063 wxPyEndAllowThreads(__tstate);
28064 if (PyErr_Occurred()) SWIG_fail;
28065 }
28066 resultobj = SWIG_Py_Void();
28067 {
28068 if (temp2)
28069 delete arg2;
28070 }
28071 return resultobj;
28072 fail:
28073 {
28074 if (temp2)
28075 delete arg2;
28076 }
28077 return NULL;
28078 }
28079
28080
28081 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28082 PyObject *resultobj = 0;
28083 long arg1 ;
28084 long val1 ;
28085 int ecode1 = 0 ;
28086 PyObject * obj0 = 0 ;
28087 char * kwnames[] = {
28088 (char *) "updateInterval", NULL
28089 };
28090
28091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
28092 ecode1 = SWIG_AsVal_long(obj0, &val1);
28093 if (!SWIG_IsOK(ecode1)) {
28094 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
28095 }
28096 arg1 = static_cast< long >(val1);
28097 {
28098 PyThreadState* __tstate = wxPyBeginAllowThreads();
28099 wxUpdateUIEvent::SetUpdateInterval(arg1);
28100 wxPyEndAllowThreads(__tstate);
28101 if (PyErr_Occurred()) SWIG_fail;
28102 }
28103 resultobj = SWIG_Py_Void();
28104 return resultobj;
28105 fail:
28106 return NULL;
28107 }
28108
28109
28110 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28111 PyObject *resultobj = 0;
28112 long result;
28113
28114 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
28115 {
28116 PyThreadState* __tstate = wxPyBeginAllowThreads();
28117 result = (long)wxUpdateUIEvent::GetUpdateInterval();
28118 wxPyEndAllowThreads(__tstate);
28119 if (PyErr_Occurred()) SWIG_fail;
28120 }
28121 resultobj = SWIG_From_long(static_cast< long >(result));
28122 return resultobj;
28123 fail:
28124 return NULL;
28125 }
28126
28127
28128 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28129 PyObject *resultobj = 0;
28130 wxWindow *arg1 = (wxWindow *) 0 ;
28131 bool result;
28132 void *argp1 = 0 ;
28133 int res1 = 0 ;
28134 PyObject * obj0 = 0 ;
28135 char * kwnames[] = {
28136 (char *) "win", NULL
28137 };
28138
28139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
28140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28141 if (!SWIG_IsOK(res1)) {
28142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
28143 }
28144 arg1 = reinterpret_cast< wxWindow * >(argp1);
28145 {
28146 PyThreadState* __tstate = wxPyBeginAllowThreads();
28147 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
28148 wxPyEndAllowThreads(__tstate);
28149 if (PyErr_Occurred()) SWIG_fail;
28150 }
28151 {
28152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28153 }
28154 return resultobj;
28155 fail:
28156 return NULL;
28157 }
28158
28159
28160 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28161 PyObject *resultobj = 0;
28162
28163 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
28164 {
28165 PyThreadState* __tstate = wxPyBeginAllowThreads();
28166 wxUpdateUIEvent::ResetUpdateTime();
28167 wxPyEndAllowThreads(__tstate);
28168 if (PyErr_Occurred()) SWIG_fail;
28169 }
28170 resultobj = SWIG_Py_Void();
28171 return resultobj;
28172 fail:
28173 return NULL;
28174 }
28175
28176
28177 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28178 PyObject *resultobj = 0;
28179 wxUpdateUIMode arg1 ;
28180 int val1 ;
28181 int ecode1 = 0 ;
28182 PyObject * obj0 = 0 ;
28183 char * kwnames[] = {
28184 (char *) "mode", NULL
28185 };
28186
28187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
28188 ecode1 = SWIG_AsVal_int(obj0, &val1);
28189 if (!SWIG_IsOK(ecode1)) {
28190 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
28191 }
28192 arg1 = static_cast< wxUpdateUIMode >(val1);
28193 {
28194 PyThreadState* __tstate = wxPyBeginAllowThreads();
28195 wxUpdateUIEvent::SetMode(arg1);
28196 wxPyEndAllowThreads(__tstate);
28197 if (PyErr_Occurred()) SWIG_fail;
28198 }
28199 resultobj = SWIG_Py_Void();
28200 return resultobj;
28201 fail:
28202 return NULL;
28203 }
28204
28205
28206 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28207 PyObject *resultobj = 0;
28208 wxUpdateUIMode result;
28209
28210 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
28211 {
28212 PyThreadState* __tstate = wxPyBeginAllowThreads();
28213 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
28214 wxPyEndAllowThreads(__tstate);
28215 if (PyErr_Occurred()) SWIG_fail;
28216 }
28217 resultobj = SWIG_From_int(static_cast< int >(result));
28218 return resultobj;
28219 fail:
28220 return NULL;
28221 }
28222
28223
28224 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28225 PyObject *obj;
28226 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28227 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
28228 return SWIG_Py_Void();
28229 }
28230
28231 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28232 return SWIG_Python_InitShadowInstance(args);
28233 }
28234
28235 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28236 PyObject *resultobj = 0;
28237 wxSysColourChangedEvent *result = 0 ;
28238
28239 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
28240 {
28241 PyThreadState* __tstate = wxPyBeginAllowThreads();
28242 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
28243 wxPyEndAllowThreads(__tstate);
28244 if (PyErr_Occurred()) SWIG_fail;
28245 }
28246 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
28247 return resultobj;
28248 fail:
28249 return NULL;
28250 }
28251
28252
28253 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28254 PyObject *obj;
28255 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28256 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
28257 return SWIG_Py_Void();
28258 }
28259
28260 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28261 return SWIG_Python_InitShadowInstance(args);
28262 }
28263
28264 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28265 PyObject *resultobj = 0;
28266 int arg1 = (int) 0 ;
28267 wxWindow *arg2 = (wxWindow *) NULL ;
28268 wxMouseCaptureChangedEvent *result = 0 ;
28269 int val1 ;
28270 int ecode1 = 0 ;
28271 void *argp2 = 0 ;
28272 int res2 = 0 ;
28273 PyObject * obj0 = 0 ;
28274 PyObject * obj1 = 0 ;
28275 char * kwnames[] = {
28276 (char *) "winid",(char *) "gainedCapture", NULL
28277 };
28278
28279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28280 if (obj0) {
28281 ecode1 = SWIG_AsVal_int(obj0, &val1);
28282 if (!SWIG_IsOK(ecode1)) {
28283 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
28284 }
28285 arg1 = static_cast< int >(val1);
28286 }
28287 if (obj1) {
28288 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28289 if (!SWIG_IsOK(res2)) {
28290 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
28291 }
28292 arg2 = reinterpret_cast< wxWindow * >(argp2);
28293 }
28294 {
28295 PyThreadState* __tstate = wxPyBeginAllowThreads();
28296 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
28297 wxPyEndAllowThreads(__tstate);
28298 if (PyErr_Occurred()) SWIG_fail;
28299 }
28300 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
28301 return resultobj;
28302 fail:
28303 return NULL;
28304 }
28305
28306
28307 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28308 PyObject *resultobj = 0;
28309 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
28310 wxWindow *result = 0 ;
28311 void *argp1 = 0 ;
28312 int res1 = 0 ;
28313 PyObject *swig_obj[1] ;
28314
28315 if (!args) SWIG_fail;
28316 swig_obj[0] = args;
28317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
28318 if (!SWIG_IsOK(res1)) {
28319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
28320 }
28321 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
28322 {
28323 PyThreadState* __tstate = wxPyBeginAllowThreads();
28324 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
28325 wxPyEndAllowThreads(__tstate);
28326 if (PyErr_Occurred()) SWIG_fail;
28327 }
28328 {
28329 resultobj = wxPyMake_wxObject(result, (bool)0);
28330 }
28331 return resultobj;
28332 fail:
28333 return NULL;
28334 }
28335
28336
28337 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28338 PyObject *obj;
28339 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28340 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
28341 return SWIG_Py_Void();
28342 }
28343
28344 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28345 return SWIG_Python_InitShadowInstance(args);
28346 }
28347
28348 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28349 PyObject *resultobj = 0;
28350 int arg1 = (int) 0 ;
28351 wxMouseCaptureLostEvent *result = 0 ;
28352 int val1 ;
28353 int ecode1 = 0 ;
28354 PyObject * obj0 = 0 ;
28355 char * kwnames[] = {
28356 (char *) "winid", NULL
28357 };
28358
28359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
28360 if (obj0) {
28361 ecode1 = SWIG_AsVal_int(obj0, &val1);
28362 if (!SWIG_IsOK(ecode1)) {
28363 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
28364 }
28365 arg1 = static_cast< int >(val1);
28366 }
28367 {
28368 PyThreadState* __tstate = wxPyBeginAllowThreads();
28369 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
28370 wxPyEndAllowThreads(__tstate);
28371 if (PyErr_Occurred()) SWIG_fail;
28372 }
28373 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
28374 return resultobj;
28375 fail:
28376 return NULL;
28377 }
28378
28379
28380 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28381 PyObject *obj;
28382 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28383 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
28384 return SWIG_Py_Void();
28385 }
28386
28387 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28388 return SWIG_Python_InitShadowInstance(args);
28389 }
28390
28391 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28392 PyObject *resultobj = 0;
28393 wxDisplayChangedEvent *result = 0 ;
28394
28395 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
28396 {
28397 PyThreadState* __tstate = wxPyBeginAllowThreads();
28398 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
28399 wxPyEndAllowThreads(__tstate);
28400 if (PyErr_Occurred()) SWIG_fail;
28401 }
28402 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
28403 return resultobj;
28404 fail:
28405 return NULL;
28406 }
28407
28408
28409 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28410 PyObject *obj;
28411 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28412 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
28413 return SWIG_Py_Void();
28414 }
28415
28416 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28417 return SWIG_Python_InitShadowInstance(args);
28418 }
28419
28420 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28421 PyObject *resultobj = 0;
28422 int arg1 = (int) 0 ;
28423 wxPaletteChangedEvent *result = 0 ;
28424 int val1 ;
28425 int ecode1 = 0 ;
28426 PyObject * obj0 = 0 ;
28427 char * kwnames[] = {
28428 (char *) "id", NULL
28429 };
28430
28431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
28432 if (obj0) {
28433 ecode1 = SWIG_AsVal_int(obj0, &val1);
28434 if (!SWIG_IsOK(ecode1)) {
28435 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
28436 }
28437 arg1 = static_cast< int >(val1);
28438 }
28439 {
28440 PyThreadState* __tstate = wxPyBeginAllowThreads();
28441 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
28442 wxPyEndAllowThreads(__tstate);
28443 if (PyErr_Occurred()) SWIG_fail;
28444 }
28445 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
28446 return resultobj;
28447 fail:
28448 return NULL;
28449 }
28450
28451
28452 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28453 PyObject *resultobj = 0;
28454 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28455 wxWindow *arg2 = (wxWindow *) 0 ;
28456 void *argp1 = 0 ;
28457 int res1 = 0 ;
28458 void *argp2 = 0 ;
28459 int res2 = 0 ;
28460 PyObject * obj0 = 0 ;
28461 PyObject * obj1 = 0 ;
28462 char * kwnames[] = {
28463 (char *) "self",(char *) "win", NULL
28464 };
28465
28466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28468 if (!SWIG_IsOK(res1)) {
28469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28470 }
28471 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28472 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28473 if (!SWIG_IsOK(res2)) {
28474 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28475 }
28476 arg2 = reinterpret_cast< wxWindow * >(argp2);
28477 {
28478 PyThreadState* __tstate = wxPyBeginAllowThreads();
28479 (arg1)->SetChangedWindow(arg2);
28480 wxPyEndAllowThreads(__tstate);
28481 if (PyErr_Occurred()) SWIG_fail;
28482 }
28483 resultobj = SWIG_Py_Void();
28484 return resultobj;
28485 fail:
28486 return NULL;
28487 }
28488
28489
28490 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28491 PyObject *resultobj = 0;
28492 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28493 wxWindow *result = 0 ;
28494 void *argp1 = 0 ;
28495 int res1 = 0 ;
28496 PyObject *swig_obj[1] ;
28497
28498 if (!args) SWIG_fail;
28499 swig_obj[0] = args;
28500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28501 if (!SWIG_IsOK(res1)) {
28502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28503 }
28504 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28505 {
28506 PyThreadState* __tstate = wxPyBeginAllowThreads();
28507 result = (wxWindow *)(arg1)->GetChangedWindow();
28508 wxPyEndAllowThreads(__tstate);
28509 if (PyErr_Occurred()) SWIG_fail;
28510 }
28511 {
28512 resultobj = wxPyMake_wxObject(result, (bool)0);
28513 }
28514 return resultobj;
28515 fail:
28516 return NULL;
28517 }
28518
28519
28520 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28521 PyObject *obj;
28522 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28523 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
28524 return SWIG_Py_Void();
28525 }
28526
28527 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28528 return SWIG_Python_InitShadowInstance(args);
28529 }
28530
28531 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28532 PyObject *resultobj = 0;
28533 int arg1 = (int) 0 ;
28534 wxQueryNewPaletteEvent *result = 0 ;
28535 int val1 ;
28536 int ecode1 = 0 ;
28537 PyObject * obj0 = 0 ;
28538 char * kwnames[] = {
28539 (char *) "winid", NULL
28540 };
28541
28542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
28543 if (obj0) {
28544 ecode1 = SWIG_AsVal_int(obj0, &val1);
28545 if (!SWIG_IsOK(ecode1)) {
28546 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
28547 }
28548 arg1 = static_cast< int >(val1);
28549 }
28550 {
28551 PyThreadState* __tstate = wxPyBeginAllowThreads();
28552 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
28553 wxPyEndAllowThreads(__tstate);
28554 if (PyErr_Occurred()) SWIG_fail;
28555 }
28556 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
28557 return resultobj;
28558 fail:
28559 return NULL;
28560 }
28561
28562
28563 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28564 PyObject *resultobj = 0;
28565 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28566 bool arg2 ;
28567 void *argp1 = 0 ;
28568 int res1 = 0 ;
28569 bool val2 ;
28570 int ecode2 = 0 ;
28571 PyObject * obj0 = 0 ;
28572 PyObject * obj1 = 0 ;
28573 char * kwnames[] = {
28574 (char *) "self",(char *) "realized", NULL
28575 };
28576
28577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
28578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28579 if (!SWIG_IsOK(res1)) {
28580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
28581 }
28582 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28583 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28584 if (!SWIG_IsOK(ecode2)) {
28585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
28586 }
28587 arg2 = static_cast< bool >(val2);
28588 {
28589 PyThreadState* __tstate = wxPyBeginAllowThreads();
28590 (arg1)->SetPaletteRealized(arg2);
28591 wxPyEndAllowThreads(__tstate);
28592 if (PyErr_Occurred()) SWIG_fail;
28593 }
28594 resultobj = SWIG_Py_Void();
28595 return resultobj;
28596 fail:
28597 return NULL;
28598 }
28599
28600
28601 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28602 PyObject *resultobj = 0;
28603 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28604 bool result;
28605 void *argp1 = 0 ;
28606 int res1 = 0 ;
28607 PyObject *swig_obj[1] ;
28608
28609 if (!args) SWIG_fail;
28610 swig_obj[0] = args;
28611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28612 if (!SWIG_IsOK(res1)) {
28613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
28614 }
28615 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28616 {
28617 PyThreadState* __tstate = wxPyBeginAllowThreads();
28618 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
28619 wxPyEndAllowThreads(__tstate);
28620 if (PyErr_Occurred()) SWIG_fail;
28621 }
28622 {
28623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28624 }
28625 return resultobj;
28626 fail:
28627 return NULL;
28628 }
28629
28630
28631 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28632 PyObject *obj;
28633 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28634 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
28635 return SWIG_Py_Void();
28636 }
28637
28638 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28639 return SWIG_Python_InitShadowInstance(args);
28640 }
28641
28642 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28643 PyObject *resultobj = 0;
28644 wxNavigationKeyEvent *result = 0 ;
28645
28646 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
28647 {
28648 PyThreadState* __tstate = wxPyBeginAllowThreads();
28649 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
28650 wxPyEndAllowThreads(__tstate);
28651 if (PyErr_Occurred()) SWIG_fail;
28652 }
28653 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
28654 return resultobj;
28655 fail:
28656 return NULL;
28657 }
28658
28659
28660 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28661 PyObject *resultobj = 0;
28662 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28663 bool result;
28664 void *argp1 = 0 ;
28665 int res1 = 0 ;
28666 PyObject *swig_obj[1] ;
28667
28668 if (!args) SWIG_fail;
28669 swig_obj[0] = args;
28670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28671 if (!SWIG_IsOK(res1)) {
28672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28673 }
28674 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28675 {
28676 PyThreadState* __tstate = wxPyBeginAllowThreads();
28677 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
28678 wxPyEndAllowThreads(__tstate);
28679 if (PyErr_Occurred()) SWIG_fail;
28680 }
28681 {
28682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28683 }
28684 return resultobj;
28685 fail:
28686 return NULL;
28687 }
28688
28689
28690 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28691 PyObject *resultobj = 0;
28692 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28693 bool arg2 ;
28694 void *argp1 = 0 ;
28695 int res1 = 0 ;
28696 bool val2 ;
28697 int ecode2 = 0 ;
28698 PyObject * obj0 = 0 ;
28699 PyObject * obj1 = 0 ;
28700 char * kwnames[] = {
28701 (char *) "self",(char *) "forward", NULL
28702 };
28703
28704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
28705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28706 if (!SWIG_IsOK(res1)) {
28707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28708 }
28709 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28710 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28711 if (!SWIG_IsOK(ecode2)) {
28712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
28713 }
28714 arg2 = static_cast< bool >(val2);
28715 {
28716 PyThreadState* __tstate = wxPyBeginAllowThreads();
28717 (arg1)->SetDirection(arg2);
28718 wxPyEndAllowThreads(__tstate);
28719 if (PyErr_Occurred()) SWIG_fail;
28720 }
28721 resultobj = SWIG_Py_Void();
28722 return resultobj;
28723 fail:
28724 return NULL;
28725 }
28726
28727
28728 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28729 PyObject *resultobj = 0;
28730 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28731 bool result;
28732 void *argp1 = 0 ;
28733 int res1 = 0 ;
28734 PyObject *swig_obj[1] ;
28735
28736 if (!args) SWIG_fail;
28737 swig_obj[0] = args;
28738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28739 if (!SWIG_IsOK(res1)) {
28740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28741 }
28742 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28743 {
28744 PyThreadState* __tstate = wxPyBeginAllowThreads();
28745 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
28746 wxPyEndAllowThreads(__tstate);
28747 if (PyErr_Occurred()) SWIG_fail;
28748 }
28749 {
28750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28751 }
28752 return resultobj;
28753 fail:
28754 return NULL;
28755 }
28756
28757
28758 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28759 PyObject *resultobj = 0;
28760 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28761 bool arg2 ;
28762 void *argp1 = 0 ;
28763 int res1 = 0 ;
28764 bool val2 ;
28765 int ecode2 = 0 ;
28766 PyObject * obj0 = 0 ;
28767 PyObject * obj1 = 0 ;
28768 char * kwnames[] = {
28769 (char *) "self",(char *) "ischange", NULL
28770 };
28771
28772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
28773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28774 if (!SWIG_IsOK(res1)) {
28775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28776 }
28777 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28778 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28779 if (!SWIG_IsOK(ecode2)) {
28780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
28781 }
28782 arg2 = static_cast< bool >(val2);
28783 {
28784 PyThreadState* __tstate = wxPyBeginAllowThreads();
28785 (arg1)->SetWindowChange(arg2);
28786 wxPyEndAllowThreads(__tstate);
28787 if (PyErr_Occurred()) SWIG_fail;
28788 }
28789 resultobj = SWIG_Py_Void();
28790 return resultobj;
28791 fail:
28792 return NULL;
28793 }
28794
28795
28796 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28797 PyObject *resultobj = 0;
28798 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28799 bool result;
28800 void *argp1 = 0 ;
28801 int res1 = 0 ;
28802 PyObject *swig_obj[1] ;
28803
28804 if (!args) SWIG_fail;
28805 swig_obj[0] = args;
28806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28807 if (!SWIG_IsOK(res1)) {
28808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28809 }
28810 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28811 {
28812 PyThreadState* __tstate = wxPyBeginAllowThreads();
28813 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
28814 wxPyEndAllowThreads(__tstate);
28815 if (PyErr_Occurred()) SWIG_fail;
28816 }
28817 {
28818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28819 }
28820 return resultobj;
28821 fail:
28822 return NULL;
28823 }
28824
28825
28826 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28827 PyObject *resultobj = 0;
28828 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28829 bool arg2 ;
28830 void *argp1 = 0 ;
28831 int res1 = 0 ;
28832 bool val2 ;
28833 int ecode2 = 0 ;
28834 PyObject * obj0 = 0 ;
28835 PyObject * obj1 = 0 ;
28836 char * kwnames[] = {
28837 (char *) "self",(char *) "bIs", NULL
28838 };
28839
28840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
28841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28842 if (!SWIG_IsOK(res1)) {
28843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28844 }
28845 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28846 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28847 if (!SWIG_IsOK(ecode2)) {
28848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
28849 }
28850 arg2 = static_cast< bool >(val2);
28851 {
28852 PyThreadState* __tstate = wxPyBeginAllowThreads();
28853 (arg1)->SetFromTab(arg2);
28854 wxPyEndAllowThreads(__tstate);
28855 if (PyErr_Occurred()) SWIG_fail;
28856 }
28857 resultobj = SWIG_Py_Void();
28858 return resultobj;
28859 fail:
28860 return NULL;
28861 }
28862
28863
28864 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28865 PyObject *resultobj = 0;
28866 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28867 long arg2 ;
28868 void *argp1 = 0 ;
28869 int res1 = 0 ;
28870 long val2 ;
28871 int ecode2 = 0 ;
28872 PyObject * obj0 = 0 ;
28873 PyObject * obj1 = 0 ;
28874 char * kwnames[] = {
28875 (char *) "self",(char *) "flags", NULL
28876 };
28877
28878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
28879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28880 if (!SWIG_IsOK(res1)) {
28881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28882 }
28883 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28884 ecode2 = SWIG_AsVal_long(obj1, &val2);
28885 if (!SWIG_IsOK(ecode2)) {
28886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
28887 }
28888 arg2 = static_cast< long >(val2);
28889 {
28890 PyThreadState* __tstate = wxPyBeginAllowThreads();
28891 (arg1)->SetFlags(arg2);
28892 wxPyEndAllowThreads(__tstate);
28893 if (PyErr_Occurred()) SWIG_fail;
28894 }
28895 resultobj = SWIG_Py_Void();
28896 return resultobj;
28897 fail:
28898 return NULL;
28899 }
28900
28901
28902 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28903 PyObject *resultobj = 0;
28904 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28905 wxWindow *result = 0 ;
28906 void *argp1 = 0 ;
28907 int res1 = 0 ;
28908 PyObject *swig_obj[1] ;
28909
28910 if (!args) SWIG_fail;
28911 swig_obj[0] = args;
28912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28913 if (!SWIG_IsOK(res1)) {
28914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28915 }
28916 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28917 {
28918 PyThreadState* __tstate = wxPyBeginAllowThreads();
28919 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
28920 wxPyEndAllowThreads(__tstate);
28921 if (PyErr_Occurred()) SWIG_fail;
28922 }
28923 {
28924 resultobj = wxPyMake_wxObject(result, (bool)0);
28925 }
28926 return resultobj;
28927 fail:
28928 return NULL;
28929 }
28930
28931
28932 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28933 PyObject *resultobj = 0;
28934 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28935 wxWindow *arg2 = (wxWindow *) 0 ;
28936 void *argp1 = 0 ;
28937 int res1 = 0 ;
28938 void *argp2 = 0 ;
28939 int res2 = 0 ;
28940 PyObject * obj0 = 0 ;
28941 PyObject * obj1 = 0 ;
28942 char * kwnames[] = {
28943 (char *) "self",(char *) "win", NULL
28944 };
28945
28946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
28947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28948 if (!SWIG_IsOK(res1)) {
28949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28950 }
28951 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28952 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28953 if (!SWIG_IsOK(res2)) {
28954 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
28955 }
28956 arg2 = reinterpret_cast< wxWindow * >(argp2);
28957 {
28958 PyThreadState* __tstate = wxPyBeginAllowThreads();
28959 (arg1)->SetCurrentFocus(arg2);
28960 wxPyEndAllowThreads(__tstate);
28961 if (PyErr_Occurred()) SWIG_fail;
28962 }
28963 resultobj = SWIG_Py_Void();
28964 return resultobj;
28965 fail:
28966 return NULL;
28967 }
28968
28969
28970 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28971 PyObject *obj;
28972 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28973 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
28974 return SWIG_Py_Void();
28975 }
28976
28977 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28978 return SWIG_Python_InitShadowInstance(args);
28979 }
28980
28981 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28982 PyObject *resultobj = 0;
28983 wxWindow *arg1 = (wxWindow *) NULL ;
28984 wxWindowCreateEvent *result = 0 ;
28985 void *argp1 = 0 ;
28986 int res1 = 0 ;
28987 PyObject * obj0 = 0 ;
28988 char * kwnames[] = {
28989 (char *) "win", NULL
28990 };
28991
28992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
28993 if (obj0) {
28994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28995 if (!SWIG_IsOK(res1)) {
28996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
28997 }
28998 arg1 = reinterpret_cast< wxWindow * >(argp1);
28999 }
29000 {
29001 PyThreadState* __tstate = wxPyBeginAllowThreads();
29002 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
29003 wxPyEndAllowThreads(__tstate);
29004 if (PyErr_Occurred()) SWIG_fail;
29005 }
29006 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
29007 return resultobj;
29008 fail:
29009 return NULL;
29010 }
29011
29012
29013 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29014 PyObject *resultobj = 0;
29015 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
29016 wxWindow *result = 0 ;
29017 void *argp1 = 0 ;
29018 int res1 = 0 ;
29019 PyObject *swig_obj[1] ;
29020
29021 if (!args) SWIG_fail;
29022 swig_obj[0] = args;
29023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
29024 if (!SWIG_IsOK(res1)) {
29025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
29026 }
29027 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
29028 {
29029 PyThreadState* __tstate = wxPyBeginAllowThreads();
29030 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
29031 wxPyEndAllowThreads(__tstate);
29032 if (PyErr_Occurred()) SWIG_fail;
29033 }
29034 {
29035 resultobj = wxPyMake_wxObject(result, (bool)0);
29036 }
29037 return resultobj;
29038 fail:
29039 return NULL;
29040 }
29041
29042
29043 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29044 PyObject *obj;
29045 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29046 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
29047 return SWIG_Py_Void();
29048 }
29049
29050 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29051 return SWIG_Python_InitShadowInstance(args);
29052 }
29053
29054 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29055 PyObject *resultobj = 0;
29056 wxWindow *arg1 = (wxWindow *) NULL ;
29057 wxWindowDestroyEvent *result = 0 ;
29058 void *argp1 = 0 ;
29059 int res1 = 0 ;
29060 PyObject * obj0 = 0 ;
29061 char * kwnames[] = {
29062 (char *) "win", NULL
29063 };
29064
29065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
29066 if (obj0) {
29067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29068 if (!SWIG_IsOK(res1)) {
29069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29070 }
29071 arg1 = reinterpret_cast< wxWindow * >(argp1);
29072 }
29073 {
29074 PyThreadState* __tstate = wxPyBeginAllowThreads();
29075 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
29076 wxPyEndAllowThreads(__tstate);
29077 if (PyErr_Occurred()) SWIG_fail;
29078 }
29079 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
29080 return resultobj;
29081 fail:
29082 return NULL;
29083 }
29084
29085
29086 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29087 PyObject *resultobj = 0;
29088 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
29089 wxWindow *result = 0 ;
29090 void *argp1 = 0 ;
29091 int res1 = 0 ;
29092 PyObject *swig_obj[1] ;
29093
29094 if (!args) SWIG_fail;
29095 swig_obj[0] = args;
29096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
29097 if (!SWIG_IsOK(res1)) {
29098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
29099 }
29100 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
29101 {
29102 PyThreadState* __tstate = wxPyBeginAllowThreads();
29103 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
29104 wxPyEndAllowThreads(__tstate);
29105 if (PyErr_Occurred()) SWIG_fail;
29106 }
29107 {
29108 resultobj = wxPyMake_wxObject(result, (bool)0);
29109 }
29110 return resultobj;
29111 fail:
29112 return NULL;
29113 }
29114
29115
29116 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29117 PyObject *obj;
29118 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29119 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
29120 return SWIG_Py_Void();
29121 }
29122
29123 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29124 return SWIG_Python_InitShadowInstance(args);
29125 }
29126
29127 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29128 PyObject *resultobj = 0;
29129 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29130 int arg2 = (int) 0 ;
29131 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29132 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29133 wxContextMenuEvent *result = 0 ;
29134 int val1 ;
29135 int ecode1 = 0 ;
29136 int val2 ;
29137 int ecode2 = 0 ;
29138 wxPoint temp3 ;
29139 PyObject * obj0 = 0 ;
29140 PyObject * obj1 = 0 ;
29141 PyObject * obj2 = 0 ;
29142 char * kwnames[] = {
29143 (char *) "type",(char *) "winid",(char *) "pt", NULL
29144 };
29145
29146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29147 if (obj0) {
29148 ecode1 = SWIG_AsVal_int(obj0, &val1);
29149 if (!SWIG_IsOK(ecode1)) {
29150 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29151 }
29152 arg1 = static_cast< wxEventType >(val1);
29153 }
29154 if (obj1) {
29155 ecode2 = SWIG_AsVal_int(obj1, &val2);
29156 if (!SWIG_IsOK(ecode2)) {
29157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
29158 }
29159 arg2 = static_cast< int >(val2);
29160 }
29161 if (obj2) {
29162 {
29163 arg3 = &temp3;
29164 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29165 }
29166 }
29167 {
29168 PyThreadState* __tstate = wxPyBeginAllowThreads();
29169 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
29170 wxPyEndAllowThreads(__tstate);
29171 if (PyErr_Occurred()) SWIG_fail;
29172 }
29173 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
29174 return resultobj;
29175 fail:
29176 return NULL;
29177 }
29178
29179
29180 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29181 PyObject *resultobj = 0;
29182 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29183 wxPoint *result = 0 ;
29184 void *argp1 = 0 ;
29185 int res1 = 0 ;
29186 PyObject *swig_obj[1] ;
29187
29188 if (!args) SWIG_fail;
29189 swig_obj[0] = args;
29190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29191 if (!SWIG_IsOK(res1)) {
29192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
29193 }
29194 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29195 {
29196 PyThreadState* __tstate = wxPyBeginAllowThreads();
29197 {
29198 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
29199 result = (wxPoint *) &_result_ref;
29200 }
29201 wxPyEndAllowThreads(__tstate);
29202 if (PyErr_Occurred()) SWIG_fail;
29203 }
29204 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
29205 return resultobj;
29206 fail:
29207 return NULL;
29208 }
29209
29210
29211 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29212 PyObject *resultobj = 0;
29213 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29214 wxPoint *arg2 = 0 ;
29215 void *argp1 = 0 ;
29216 int res1 = 0 ;
29217 wxPoint temp2 ;
29218 PyObject * obj0 = 0 ;
29219 PyObject * obj1 = 0 ;
29220 char * kwnames[] = {
29221 (char *) "self",(char *) "pos", NULL
29222 };
29223
29224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
29225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29226 if (!SWIG_IsOK(res1)) {
29227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
29228 }
29229 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29230 {
29231 arg2 = &temp2;
29232 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29233 }
29234 {
29235 PyThreadState* __tstate = wxPyBeginAllowThreads();
29236 (arg1)->SetPosition((wxPoint const &)*arg2);
29237 wxPyEndAllowThreads(__tstate);
29238 if (PyErr_Occurred()) SWIG_fail;
29239 }
29240 resultobj = SWIG_Py_Void();
29241 return resultobj;
29242 fail:
29243 return NULL;
29244 }
29245
29246
29247 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29248 PyObject *obj;
29249 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29250 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
29251 return SWIG_Py_Void();
29252 }
29253
29254 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29255 return SWIG_Python_InitShadowInstance(args);
29256 }
29257
29258 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29259 PyObject *resultobj = 0;
29260 wxIdleEvent *result = 0 ;
29261
29262 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
29263 {
29264 PyThreadState* __tstate = wxPyBeginAllowThreads();
29265 result = (wxIdleEvent *)new wxIdleEvent();
29266 wxPyEndAllowThreads(__tstate);
29267 if (PyErr_Occurred()) SWIG_fail;
29268 }
29269 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
29270 return resultobj;
29271 fail:
29272 return NULL;
29273 }
29274
29275
29276 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29277 PyObject *resultobj = 0;
29278 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29279 bool arg2 = (bool) true ;
29280 void *argp1 = 0 ;
29281 int res1 = 0 ;
29282 bool val2 ;
29283 int ecode2 = 0 ;
29284 PyObject * obj0 = 0 ;
29285 PyObject * obj1 = 0 ;
29286 char * kwnames[] = {
29287 (char *) "self",(char *) "needMore", NULL
29288 };
29289
29290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
29291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29292 if (!SWIG_IsOK(res1)) {
29293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
29294 }
29295 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29296 if (obj1) {
29297 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29298 if (!SWIG_IsOK(ecode2)) {
29299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
29300 }
29301 arg2 = static_cast< bool >(val2);
29302 }
29303 {
29304 PyThreadState* __tstate = wxPyBeginAllowThreads();
29305 (arg1)->RequestMore(arg2);
29306 wxPyEndAllowThreads(__tstate);
29307 if (PyErr_Occurred()) SWIG_fail;
29308 }
29309 resultobj = SWIG_Py_Void();
29310 return resultobj;
29311 fail:
29312 return NULL;
29313 }
29314
29315
29316 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29317 PyObject *resultobj = 0;
29318 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29319 bool result;
29320 void *argp1 = 0 ;
29321 int res1 = 0 ;
29322 PyObject *swig_obj[1] ;
29323
29324 if (!args) SWIG_fail;
29325 swig_obj[0] = args;
29326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29327 if (!SWIG_IsOK(res1)) {
29328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
29329 }
29330 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29331 {
29332 PyThreadState* __tstate = wxPyBeginAllowThreads();
29333 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
29334 wxPyEndAllowThreads(__tstate);
29335 if (PyErr_Occurred()) SWIG_fail;
29336 }
29337 {
29338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29339 }
29340 return resultobj;
29341 fail:
29342 return NULL;
29343 }
29344
29345
29346 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29347 PyObject *resultobj = 0;
29348 wxIdleMode arg1 ;
29349 int val1 ;
29350 int ecode1 = 0 ;
29351 PyObject * obj0 = 0 ;
29352 char * kwnames[] = {
29353 (char *) "mode", NULL
29354 };
29355
29356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
29357 ecode1 = SWIG_AsVal_int(obj0, &val1);
29358 if (!SWIG_IsOK(ecode1)) {
29359 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
29360 }
29361 arg1 = static_cast< wxIdleMode >(val1);
29362 {
29363 PyThreadState* __tstate = wxPyBeginAllowThreads();
29364 wxIdleEvent::SetMode(arg1);
29365 wxPyEndAllowThreads(__tstate);
29366 if (PyErr_Occurred()) SWIG_fail;
29367 }
29368 resultobj = SWIG_Py_Void();
29369 return resultobj;
29370 fail:
29371 return NULL;
29372 }
29373
29374
29375 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29376 PyObject *resultobj = 0;
29377 wxIdleMode result;
29378
29379 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
29380 {
29381 PyThreadState* __tstate = wxPyBeginAllowThreads();
29382 result = (wxIdleMode)wxIdleEvent::GetMode();
29383 wxPyEndAllowThreads(__tstate);
29384 if (PyErr_Occurred()) SWIG_fail;
29385 }
29386 resultobj = SWIG_From_int(static_cast< int >(result));
29387 return resultobj;
29388 fail:
29389 return NULL;
29390 }
29391
29392
29393 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29394 PyObject *resultobj = 0;
29395 wxWindow *arg1 = (wxWindow *) 0 ;
29396 bool result;
29397 void *argp1 = 0 ;
29398 int res1 = 0 ;
29399 PyObject * obj0 = 0 ;
29400 char * kwnames[] = {
29401 (char *) "win", NULL
29402 };
29403
29404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
29405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29406 if (!SWIG_IsOK(res1)) {
29407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
29408 }
29409 arg1 = reinterpret_cast< wxWindow * >(argp1);
29410 {
29411 PyThreadState* __tstate = wxPyBeginAllowThreads();
29412 result = (bool)wxIdleEvent::CanSend(arg1);
29413 wxPyEndAllowThreads(__tstate);
29414 if (PyErr_Occurred()) SWIG_fail;
29415 }
29416 {
29417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29418 }
29419 return resultobj;
29420 fail:
29421 return NULL;
29422 }
29423
29424
29425 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29426 PyObject *obj;
29427 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29428 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
29429 return SWIG_Py_Void();
29430 }
29431
29432 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29433 return SWIG_Python_InitShadowInstance(args);
29434 }
29435
29436 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29437 PyObject *resultobj = 0;
29438 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29439 int arg2 = (int) 0 ;
29440 wxClipboardTextEvent *result = 0 ;
29441 int val1 ;
29442 int ecode1 = 0 ;
29443 int val2 ;
29444 int ecode2 = 0 ;
29445 PyObject * obj0 = 0 ;
29446 PyObject * obj1 = 0 ;
29447 char * kwnames[] = {
29448 (char *) "type",(char *) "winid", NULL
29449 };
29450
29451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29452 if (obj0) {
29453 ecode1 = SWIG_AsVal_int(obj0, &val1);
29454 if (!SWIG_IsOK(ecode1)) {
29455 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29456 }
29457 arg1 = static_cast< wxEventType >(val1);
29458 }
29459 if (obj1) {
29460 ecode2 = SWIG_AsVal_int(obj1, &val2);
29461 if (!SWIG_IsOK(ecode2)) {
29462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
29463 }
29464 arg2 = static_cast< int >(val2);
29465 }
29466 {
29467 PyThreadState* __tstate = wxPyBeginAllowThreads();
29468 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
29469 wxPyEndAllowThreads(__tstate);
29470 if (PyErr_Occurred()) SWIG_fail;
29471 }
29472 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
29473 return resultobj;
29474 fail:
29475 return NULL;
29476 }
29477
29478
29479 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29480 PyObject *obj;
29481 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29482 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
29483 return SWIG_Py_Void();
29484 }
29485
29486 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29487 return SWIG_Python_InitShadowInstance(args);
29488 }
29489
29490 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29491 PyObject *resultobj = 0;
29492 int arg1 = (int) 0 ;
29493 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
29494 wxPyEvent *result = 0 ;
29495 int val1 ;
29496 int ecode1 = 0 ;
29497 int val2 ;
29498 int ecode2 = 0 ;
29499 PyObject * obj0 = 0 ;
29500 PyObject * obj1 = 0 ;
29501 char * kwnames[] = {
29502 (char *) "winid",(char *) "eventType", NULL
29503 };
29504
29505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29506 if (obj0) {
29507 ecode1 = SWIG_AsVal_int(obj0, &val1);
29508 if (!SWIG_IsOK(ecode1)) {
29509 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
29510 }
29511 arg1 = static_cast< int >(val1);
29512 }
29513 if (obj1) {
29514 ecode2 = SWIG_AsVal_int(obj1, &val2);
29515 if (!SWIG_IsOK(ecode2)) {
29516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
29517 }
29518 arg2 = static_cast< wxEventType >(val2);
29519 }
29520 {
29521 PyThreadState* __tstate = wxPyBeginAllowThreads();
29522 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
29523 wxPyEndAllowThreads(__tstate);
29524 if (PyErr_Occurred()) SWIG_fail;
29525 }
29526 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
29527 return resultobj;
29528 fail:
29529 return NULL;
29530 }
29531
29532
29533 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29534 PyObject *resultobj = 0;
29535 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29536 void *argp1 = 0 ;
29537 int res1 = 0 ;
29538 PyObject *swig_obj[1] ;
29539
29540 if (!args) SWIG_fail;
29541 swig_obj[0] = args;
29542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
29543 if (!SWIG_IsOK(res1)) {
29544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29545 }
29546 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29547 {
29548 PyThreadState* __tstate = wxPyBeginAllowThreads();
29549 delete arg1;
29550
29551 wxPyEndAllowThreads(__tstate);
29552 if (PyErr_Occurred()) SWIG_fail;
29553 }
29554 resultobj = SWIG_Py_Void();
29555 return resultobj;
29556 fail:
29557 return NULL;
29558 }
29559
29560
29561 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29562 PyObject *resultobj = 0;
29563 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29564 PyObject *arg2 = (PyObject *) 0 ;
29565 void *argp1 = 0 ;
29566 int res1 = 0 ;
29567 PyObject * obj0 = 0 ;
29568 PyObject * obj1 = 0 ;
29569 char * kwnames[] = {
29570 (char *) "self",(char *) "self", NULL
29571 };
29572
29573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29575 if (!SWIG_IsOK(res1)) {
29576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29577 }
29578 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29579 arg2 = obj1;
29580 {
29581 PyThreadState* __tstate = wxPyBeginAllowThreads();
29582 (arg1)->SetSelf(arg2);
29583 wxPyEndAllowThreads(__tstate);
29584 if (PyErr_Occurred()) SWIG_fail;
29585 }
29586 resultobj = SWIG_Py_Void();
29587 return resultobj;
29588 fail:
29589 return NULL;
29590 }
29591
29592
29593 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29594 PyObject *resultobj = 0;
29595 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29596 PyObject *result = 0 ;
29597 void *argp1 = 0 ;
29598 int res1 = 0 ;
29599 PyObject *swig_obj[1] ;
29600
29601 if (!args) SWIG_fail;
29602 swig_obj[0] = args;
29603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29604 if (!SWIG_IsOK(res1)) {
29605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29606 }
29607 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29608 {
29609 PyThreadState* __tstate = wxPyBeginAllowThreads();
29610 result = (PyObject *)(arg1)->GetSelf();
29611 wxPyEndAllowThreads(__tstate);
29612 if (PyErr_Occurred()) SWIG_fail;
29613 }
29614 resultobj = result;
29615 return resultobj;
29616 fail:
29617 return NULL;
29618 }
29619
29620
29621 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29622 PyObject *obj;
29623 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29624 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
29625 return SWIG_Py_Void();
29626 }
29627
29628 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29629 return SWIG_Python_InitShadowInstance(args);
29630 }
29631
29632 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29633 PyObject *resultobj = 0;
29634 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29635 int arg2 = (int) 0 ;
29636 wxPyCommandEvent *result = 0 ;
29637 int val1 ;
29638 int ecode1 = 0 ;
29639 int val2 ;
29640 int ecode2 = 0 ;
29641 PyObject * obj0 = 0 ;
29642 PyObject * obj1 = 0 ;
29643 char * kwnames[] = {
29644 (char *) "eventType",(char *) "id", NULL
29645 };
29646
29647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29648 if (obj0) {
29649 ecode1 = SWIG_AsVal_int(obj0, &val1);
29650 if (!SWIG_IsOK(ecode1)) {
29651 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29652 }
29653 arg1 = static_cast< wxEventType >(val1);
29654 }
29655 if (obj1) {
29656 ecode2 = SWIG_AsVal_int(obj1, &val2);
29657 if (!SWIG_IsOK(ecode2)) {
29658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
29659 }
29660 arg2 = static_cast< int >(val2);
29661 }
29662 {
29663 PyThreadState* __tstate = wxPyBeginAllowThreads();
29664 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
29665 wxPyEndAllowThreads(__tstate);
29666 if (PyErr_Occurred()) SWIG_fail;
29667 }
29668 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
29669 return resultobj;
29670 fail:
29671 return NULL;
29672 }
29673
29674
29675 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29676 PyObject *resultobj = 0;
29677 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29678 void *argp1 = 0 ;
29679 int res1 = 0 ;
29680 PyObject *swig_obj[1] ;
29681
29682 if (!args) SWIG_fail;
29683 swig_obj[0] = args;
29684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
29685 if (!SWIG_IsOK(res1)) {
29686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29687 }
29688 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29689 {
29690 PyThreadState* __tstate = wxPyBeginAllowThreads();
29691 delete arg1;
29692
29693 wxPyEndAllowThreads(__tstate);
29694 if (PyErr_Occurred()) SWIG_fail;
29695 }
29696 resultobj = SWIG_Py_Void();
29697 return resultobj;
29698 fail:
29699 return NULL;
29700 }
29701
29702
29703 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29704 PyObject *resultobj = 0;
29705 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29706 PyObject *arg2 = (PyObject *) 0 ;
29707 void *argp1 = 0 ;
29708 int res1 = 0 ;
29709 PyObject * obj0 = 0 ;
29710 PyObject * obj1 = 0 ;
29711 char * kwnames[] = {
29712 (char *) "self",(char *) "self", NULL
29713 };
29714
29715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29717 if (!SWIG_IsOK(res1)) {
29718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29719 }
29720 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29721 arg2 = obj1;
29722 {
29723 PyThreadState* __tstate = wxPyBeginAllowThreads();
29724 (arg1)->SetSelf(arg2);
29725 wxPyEndAllowThreads(__tstate);
29726 if (PyErr_Occurred()) SWIG_fail;
29727 }
29728 resultobj = SWIG_Py_Void();
29729 return resultobj;
29730 fail:
29731 return NULL;
29732 }
29733
29734
29735 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29736 PyObject *resultobj = 0;
29737 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29738 PyObject *result = 0 ;
29739 void *argp1 = 0 ;
29740 int res1 = 0 ;
29741 PyObject *swig_obj[1] ;
29742
29743 if (!args) SWIG_fail;
29744 swig_obj[0] = args;
29745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29746 if (!SWIG_IsOK(res1)) {
29747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29748 }
29749 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29750 {
29751 PyThreadState* __tstate = wxPyBeginAllowThreads();
29752 result = (PyObject *)(arg1)->GetSelf();
29753 wxPyEndAllowThreads(__tstate);
29754 if (PyErr_Occurred()) SWIG_fail;
29755 }
29756 resultobj = result;
29757 return resultobj;
29758 fail:
29759 return NULL;
29760 }
29761
29762
29763 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29764 PyObject *obj;
29765 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29766 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
29767 return SWIG_Py_Void();
29768 }
29769
29770 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29771 return SWIG_Python_InitShadowInstance(args);
29772 }
29773
29774 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29775 PyObject *resultobj = 0;
29776 wxWindow *arg1 = (wxWindow *) 0 ;
29777 wxDateTime *arg2 = 0 ;
29778 wxEventType arg3 ;
29779 wxDateEvent *result = 0 ;
29780 void *argp1 = 0 ;
29781 int res1 = 0 ;
29782 void *argp2 = 0 ;
29783 int res2 = 0 ;
29784 int val3 ;
29785 int ecode3 = 0 ;
29786 PyObject * obj0 = 0 ;
29787 PyObject * obj1 = 0 ;
29788 PyObject * obj2 = 0 ;
29789 char * kwnames[] = {
29790 (char *) "win",(char *) "dt",(char *) "type", NULL
29791 };
29792
29793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29795 if (!SWIG_IsOK(res1)) {
29796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29797 }
29798 arg1 = reinterpret_cast< wxWindow * >(argp1);
29799 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29800 if (!SWIG_IsOK(res2)) {
29801 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29802 }
29803 if (!argp2) {
29804 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29805 }
29806 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29807 ecode3 = SWIG_AsVal_int(obj2, &val3);
29808 if (!SWIG_IsOK(ecode3)) {
29809 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
29810 }
29811 arg3 = static_cast< wxEventType >(val3);
29812 {
29813 PyThreadState* __tstate = wxPyBeginAllowThreads();
29814 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
29815 wxPyEndAllowThreads(__tstate);
29816 if (PyErr_Occurred()) SWIG_fail;
29817 }
29818 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
29819 return resultobj;
29820 fail:
29821 return NULL;
29822 }
29823
29824
29825 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29826 PyObject *resultobj = 0;
29827 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29828 wxDateTime *result = 0 ;
29829 void *argp1 = 0 ;
29830 int res1 = 0 ;
29831 PyObject *swig_obj[1] ;
29832
29833 if (!args) SWIG_fail;
29834 swig_obj[0] = args;
29835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29836 if (!SWIG_IsOK(res1)) {
29837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
29838 }
29839 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29840 {
29841 PyThreadState* __tstate = wxPyBeginAllowThreads();
29842 {
29843 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
29844 result = (wxDateTime *) &_result_ref;
29845 }
29846 wxPyEndAllowThreads(__tstate);
29847 if (PyErr_Occurred()) SWIG_fail;
29848 }
29849 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
29850 return resultobj;
29851 fail:
29852 return NULL;
29853 }
29854
29855
29856 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29857 PyObject *resultobj = 0;
29858 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29859 wxDateTime *arg2 = 0 ;
29860 void *argp1 = 0 ;
29861 int res1 = 0 ;
29862 void *argp2 = 0 ;
29863 int res2 = 0 ;
29864 PyObject * obj0 = 0 ;
29865 PyObject * obj1 = 0 ;
29866 char * kwnames[] = {
29867 (char *) "self",(char *) "date", NULL
29868 };
29869
29870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
29871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29872 if (!SWIG_IsOK(res1)) {
29873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
29874 }
29875 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29876 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29877 if (!SWIG_IsOK(res2)) {
29878 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29879 }
29880 if (!argp2) {
29881 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29882 }
29883 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29884 {
29885 PyThreadState* __tstate = wxPyBeginAllowThreads();
29886 (arg1)->SetDate((wxDateTime const &)*arg2);
29887 wxPyEndAllowThreads(__tstate);
29888 if (PyErr_Occurred()) SWIG_fail;
29889 }
29890 resultobj = SWIG_Py_Void();
29891 return resultobj;
29892 fail:
29893 return NULL;
29894 }
29895
29896
29897 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29898 PyObject *obj;
29899 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29900 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
29901 return SWIG_Py_Void();
29902 }
29903
29904 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29905 return SWIG_Python_InitShadowInstance(args);
29906 }
29907
29908 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29909 PyObject *resultobj = 0;
29910 wxPyApp *result = 0 ;
29911
29912 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
29913 {
29914 PyThreadState* __tstate = wxPyBeginAllowThreads();
29915 result = (wxPyApp *)new_wxPyApp();
29916 wxPyEndAllowThreads(__tstate);
29917 if (PyErr_Occurred()) SWIG_fail;
29918 }
29919 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
29920 return resultobj;
29921 fail:
29922 return NULL;
29923 }
29924
29925
29926 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29927 PyObject *resultobj = 0;
29928 wxPyApp *arg1 = (wxPyApp *) 0 ;
29929 void *argp1 = 0 ;
29930 int res1 = 0 ;
29931 PyObject *swig_obj[1] ;
29932
29933 if (!args) SWIG_fail;
29934 swig_obj[0] = args;
29935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
29936 if (!SWIG_IsOK(res1)) {
29937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
29938 }
29939 arg1 = reinterpret_cast< wxPyApp * >(argp1);
29940 {
29941 PyThreadState* __tstate = wxPyBeginAllowThreads();
29942 delete arg1;
29943
29944 wxPyEndAllowThreads(__tstate);
29945 if (PyErr_Occurred()) SWIG_fail;
29946 }
29947 resultobj = SWIG_Py_Void();
29948 return resultobj;
29949 fail:
29950 return NULL;
29951 }
29952
29953
29954 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29955 PyObject *resultobj = 0;
29956 wxPyApp *arg1 = (wxPyApp *) 0 ;
29957 PyObject *arg2 = (PyObject *) 0 ;
29958 PyObject *arg3 = (PyObject *) 0 ;
29959 bool arg4 = (bool) false ;
29960 void *argp1 = 0 ;
29961 int res1 = 0 ;
29962 bool val4 ;
29963 int ecode4 = 0 ;
29964 PyObject * obj0 = 0 ;
29965 PyObject * obj1 = 0 ;
29966 PyObject * obj2 = 0 ;
29967 PyObject * obj3 = 0 ;
29968 char * kwnames[] = {
29969 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
29970 };
29971
29972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
29974 if (!SWIG_IsOK(res1)) {
29975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
29976 }
29977 arg1 = reinterpret_cast< wxPyApp * >(argp1);
29978 arg2 = obj1;
29979 arg3 = obj2;
29980 if (obj3) {
29981 ecode4 = SWIG_AsVal_bool(obj3, &val4);
29982 if (!SWIG_IsOK(ecode4)) {
29983 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
29984 }
29985 arg4 = static_cast< bool >(val4);
29986 }
29987 {
29988 PyThreadState* __tstate = wxPyBeginAllowThreads();
29989 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
29990 wxPyEndAllowThreads(__tstate);
29991 if (PyErr_Occurred()) SWIG_fail;
29992 }
29993 resultobj = SWIG_Py_Void();
29994 return resultobj;
29995 fail:
29996 return NULL;
29997 }
29998
29999
30000 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30001 PyObject *resultobj = 0;
30002 wxPyApp *arg1 = (wxPyApp *) 0 ;
30003 wxString result;
30004 void *argp1 = 0 ;
30005 int res1 = 0 ;
30006 PyObject *swig_obj[1] ;
30007
30008 if (!args) SWIG_fail;
30009 swig_obj[0] = args;
30010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30011 if (!SWIG_IsOK(res1)) {
30012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30013 }
30014 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30015 {
30016 PyThreadState* __tstate = wxPyBeginAllowThreads();
30017 result = ((wxPyApp const *)arg1)->GetAppName();
30018 wxPyEndAllowThreads(__tstate);
30019 if (PyErr_Occurred()) SWIG_fail;
30020 }
30021 {
30022 #if wxUSE_UNICODE
30023 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30024 #else
30025 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30026 #endif
30027 }
30028 return resultobj;
30029 fail:
30030 return NULL;
30031 }
30032
30033
30034 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30035 PyObject *resultobj = 0;
30036 wxPyApp *arg1 = (wxPyApp *) 0 ;
30037 wxString *arg2 = 0 ;
30038 void *argp1 = 0 ;
30039 int res1 = 0 ;
30040 bool temp2 = false ;
30041 PyObject * obj0 = 0 ;
30042 PyObject * obj1 = 0 ;
30043 char * kwnames[] = {
30044 (char *) "self",(char *) "name", NULL
30045 };
30046
30047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
30048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30049 if (!SWIG_IsOK(res1)) {
30050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30051 }
30052 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30053 {
30054 arg2 = wxString_in_helper(obj1);
30055 if (arg2 == NULL) SWIG_fail;
30056 temp2 = true;
30057 }
30058 {
30059 PyThreadState* __tstate = wxPyBeginAllowThreads();
30060 (arg1)->SetAppName((wxString const &)*arg2);
30061 wxPyEndAllowThreads(__tstate);
30062 if (PyErr_Occurred()) SWIG_fail;
30063 }
30064 resultobj = SWIG_Py_Void();
30065 {
30066 if (temp2)
30067 delete arg2;
30068 }
30069 return resultobj;
30070 fail:
30071 {
30072 if (temp2)
30073 delete arg2;
30074 }
30075 return NULL;
30076 }
30077
30078
30079 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30080 PyObject *resultobj = 0;
30081 wxPyApp *arg1 = (wxPyApp *) 0 ;
30082 wxString result;
30083 void *argp1 = 0 ;
30084 int res1 = 0 ;
30085 PyObject *swig_obj[1] ;
30086
30087 if (!args) SWIG_fail;
30088 swig_obj[0] = args;
30089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30090 if (!SWIG_IsOK(res1)) {
30091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30092 }
30093 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30094 {
30095 PyThreadState* __tstate = wxPyBeginAllowThreads();
30096 result = ((wxPyApp const *)arg1)->GetClassName();
30097 wxPyEndAllowThreads(__tstate);
30098 if (PyErr_Occurred()) SWIG_fail;
30099 }
30100 {
30101 #if wxUSE_UNICODE
30102 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30103 #else
30104 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30105 #endif
30106 }
30107 return resultobj;
30108 fail:
30109 return NULL;
30110 }
30111
30112
30113 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30114 PyObject *resultobj = 0;
30115 wxPyApp *arg1 = (wxPyApp *) 0 ;
30116 wxString *arg2 = 0 ;
30117 void *argp1 = 0 ;
30118 int res1 = 0 ;
30119 bool temp2 = false ;
30120 PyObject * obj0 = 0 ;
30121 PyObject * obj1 = 0 ;
30122 char * kwnames[] = {
30123 (char *) "self",(char *) "name", NULL
30124 };
30125
30126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
30127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30128 if (!SWIG_IsOK(res1)) {
30129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30130 }
30131 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30132 {
30133 arg2 = wxString_in_helper(obj1);
30134 if (arg2 == NULL) SWIG_fail;
30135 temp2 = true;
30136 }
30137 {
30138 PyThreadState* __tstate = wxPyBeginAllowThreads();
30139 (arg1)->SetClassName((wxString const &)*arg2);
30140 wxPyEndAllowThreads(__tstate);
30141 if (PyErr_Occurred()) SWIG_fail;
30142 }
30143 resultobj = SWIG_Py_Void();
30144 {
30145 if (temp2)
30146 delete arg2;
30147 }
30148 return resultobj;
30149 fail:
30150 {
30151 if (temp2)
30152 delete arg2;
30153 }
30154 return NULL;
30155 }
30156
30157
30158 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30159 PyObject *resultobj = 0;
30160 wxPyApp *arg1 = (wxPyApp *) 0 ;
30161 wxString *result = 0 ;
30162 void *argp1 = 0 ;
30163 int res1 = 0 ;
30164 PyObject *swig_obj[1] ;
30165
30166 if (!args) SWIG_fail;
30167 swig_obj[0] = args;
30168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30169 if (!SWIG_IsOK(res1)) {
30170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30171 }
30172 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30173 {
30174 PyThreadState* __tstate = wxPyBeginAllowThreads();
30175 {
30176 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
30177 result = (wxString *) &_result_ref;
30178 }
30179 wxPyEndAllowThreads(__tstate);
30180 if (PyErr_Occurred()) SWIG_fail;
30181 }
30182 {
30183 #if wxUSE_UNICODE
30184 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
30185 #else
30186 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
30187 #endif
30188 }
30189 return resultobj;
30190 fail:
30191 return NULL;
30192 }
30193
30194
30195 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30196 PyObject *resultobj = 0;
30197 wxPyApp *arg1 = (wxPyApp *) 0 ;
30198 wxString *arg2 = 0 ;
30199 void *argp1 = 0 ;
30200 int res1 = 0 ;
30201 bool temp2 = false ;
30202 PyObject * obj0 = 0 ;
30203 PyObject * obj1 = 0 ;
30204 char * kwnames[] = {
30205 (char *) "self",(char *) "name", NULL
30206 };
30207
30208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
30209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30210 if (!SWIG_IsOK(res1)) {
30211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30212 }
30213 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30214 {
30215 arg2 = wxString_in_helper(obj1);
30216 if (arg2 == NULL) SWIG_fail;
30217 temp2 = true;
30218 }
30219 {
30220 PyThreadState* __tstate = wxPyBeginAllowThreads();
30221 (arg1)->SetVendorName((wxString const &)*arg2);
30222 wxPyEndAllowThreads(__tstate);
30223 if (PyErr_Occurred()) SWIG_fail;
30224 }
30225 resultobj = SWIG_Py_Void();
30226 {
30227 if (temp2)
30228 delete arg2;
30229 }
30230 return resultobj;
30231 fail:
30232 {
30233 if (temp2)
30234 delete arg2;
30235 }
30236 return NULL;
30237 }
30238
30239
30240 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30241 PyObject *resultobj = 0;
30242 wxPyApp *arg1 = (wxPyApp *) 0 ;
30243 wxAppTraits *result = 0 ;
30244 void *argp1 = 0 ;
30245 int res1 = 0 ;
30246 PyObject *swig_obj[1] ;
30247
30248 if (!args) SWIG_fail;
30249 swig_obj[0] = args;
30250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30251 if (!SWIG_IsOK(res1)) {
30252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
30253 }
30254 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30255 {
30256 PyThreadState* __tstate = wxPyBeginAllowThreads();
30257 result = (wxAppTraits *)(arg1)->GetTraits();
30258 wxPyEndAllowThreads(__tstate);
30259 if (PyErr_Occurred()) SWIG_fail;
30260 }
30261 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
30262 return resultobj;
30263 fail:
30264 return NULL;
30265 }
30266
30267
30268 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30269 PyObject *resultobj = 0;
30270 wxPyApp *arg1 = (wxPyApp *) 0 ;
30271 void *argp1 = 0 ;
30272 int res1 = 0 ;
30273 PyObject *swig_obj[1] ;
30274
30275 if (!args) SWIG_fail;
30276 swig_obj[0] = args;
30277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30278 if (!SWIG_IsOK(res1)) {
30279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30280 }
30281 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30282 {
30283 PyThreadState* __tstate = wxPyBeginAllowThreads();
30284 (arg1)->ProcessPendingEvents();
30285 wxPyEndAllowThreads(__tstate);
30286 if (PyErr_Occurred()) SWIG_fail;
30287 }
30288 resultobj = SWIG_Py_Void();
30289 return resultobj;
30290 fail:
30291 return NULL;
30292 }
30293
30294
30295 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30296 PyObject *resultobj = 0;
30297 wxPyApp *arg1 = (wxPyApp *) 0 ;
30298 bool arg2 = (bool) false ;
30299 bool result;
30300 void *argp1 = 0 ;
30301 int res1 = 0 ;
30302 bool val2 ;
30303 int ecode2 = 0 ;
30304 PyObject * obj0 = 0 ;
30305 PyObject * obj1 = 0 ;
30306 char * kwnames[] = {
30307 (char *) "self",(char *) "onlyIfNeeded", NULL
30308 };
30309
30310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
30311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30312 if (!SWIG_IsOK(res1)) {
30313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
30314 }
30315 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30316 if (obj1) {
30317 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30318 if (!SWIG_IsOK(ecode2)) {
30319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
30320 }
30321 arg2 = static_cast< bool >(val2);
30322 }
30323 {
30324 PyThreadState* __tstate = wxPyBeginAllowThreads();
30325 result = (bool)(arg1)->Yield(arg2);
30326 wxPyEndAllowThreads(__tstate);
30327 if (PyErr_Occurred()) SWIG_fail;
30328 }
30329 {
30330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30331 }
30332 return resultobj;
30333 fail:
30334 return NULL;
30335 }
30336
30337
30338 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30339 PyObject *resultobj = 0;
30340 wxPyApp *arg1 = (wxPyApp *) 0 ;
30341 void *argp1 = 0 ;
30342 int res1 = 0 ;
30343 PyObject *swig_obj[1] ;
30344
30345 if (!args) SWIG_fail;
30346 swig_obj[0] = args;
30347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30348 if (!SWIG_IsOK(res1)) {
30349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30350 }
30351 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30352 {
30353 PyThreadState* __tstate = wxPyBeginAllowThreads();
30354 (arg1)->WakeUpIdle();
30355 wxPyEndAllowThreads(__tstate);
30356 if (PyErr_Occurred()) SWIG_fail;
30357 }
30358 resultobj = SWIG_Py_Void();
30359 return resultobj;
30360 fail:
30361 return NULL;
30362 }
30363
30364
30365 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30366 PyObject *resultobj = 0;
30367 bool result;
30368
30369 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
30370 {
30371 PyThreadState* __tstate = wxPyBeginAllowThreads();
30372 result = (bool)wxPyApp::IsMainLoopRunning();
30373 wxPyEndAllowThreads(__tstate);
30374 if (PyErr_Occurred()) SWIG_fail;
30375 }
30376 {
30377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30378 }
30379 return resultobj;
30380 fail:
30381 return NULL;
30382 }
30383
30384
30385 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30386 PyObject *resultobj = 0;
30387 wxPyApp *arg1 = (wxPyApp *) 0 ;
30388 int result;
30389 void *argp1 = 0 ;
30390 int res1 = 0 ;
30391 PyObject *swig_obj[1] ;
30392
30393 if (!args) SWIG_fail;
30394 swig_obj[0] = args;
30395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30396 if (!SWIG_IsOK(res1)) {
30397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30398 }
30399 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30400 {
30401 PyThreadState* __tstate = wxPyBeginAllowThreads();
30402 result = (int)(arg1)->MainLoop();
30403 wxPyEndAllowThreads(__tstate);
30404 if (PyErr_Occurred()) SWIG_fail;
30405 }
30406 resultobj = SWIG_From_int(static_cast< int >(result));
30407 return resultobj;
30408 fail:
30409 return NULL;
30410 }
30411
30412
30413 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30414 PyObject *resultobj = 0;
30415 wxPyApp *arg1 = (wxPyApp *) 0 ;
30416 void *argp1 = 0 ;
30417 int res1 = 0 ;
30418 PyObject *swig_obj[1] ;
30419
30420 if (!args) SWIG_fail;
30421 swig_obj[0] = args;
30422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30423 if (!SWIG_IsOK(res1)) {
30424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
30425 }
30426 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30427 {
30428 PyThreadState* __tstate = wxPyBeginAllowThreads();
30429 (arg1)->Exit();
30430 wxPyEndAllowThreads(__tstate);
30431 if (PyErr_Occurred()) SWIG_fail;
30432 }
30433 resultobj = SWIG_Py_Void();
30434 return resultobj;
30435 fail:
30436 return NULL;
30437 }
30438
30439
30440 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30441 PyObject *resultobj = 0;
30442 wxPyApp *arg1 = (wxPyApp *) 0 ;
30443 wxLayoutDirection result;
30444 void *argp1 = 0 ;
30445 int res1 = 0 ;
30446 PyObject *swig_obj[1] ;
30447
30448 if (!args) SWIG_fail;
30449 swig_obj[0] = args;
30450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30451 if (!SWIG_IsOK(res1)) {
30452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30453 }
30454 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30455 {
30456 PyThreadState* __tstate = wxPyBeginAllowThreads();
30457 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
30458 wxPyEndAllowThreads(__tstate);
30459 if (PyErr_Occurred()) SWIG_fail;
30460 }
30461 resultobj = SWIG_From_int(static_cast< int >(result));
30462 return resultobj;
30463 fail:
30464 return NULL;
30465 }
30466
30467
30468 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30469 PyObject *resultobj = 0;
30470 wxPyApp *arg1 = (wxPyApp *) 0 ;
30471 void *argp1 = 0 ;
30472 int res1 = 0 ;
30473 PyObject *swig_obj[1] ;
30474
30475 if (!args) SWIG_fail;
30476 swig_obj[0] = args;
30477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30478 if (!SWIG_IsOK(res1)) {
30479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30480 }
30481 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30482 {
30483 PyThreadState* __tstate = wxPyBeginAllowThreads();
30484 (arg1)->ExitMainLoop();
30485 wxPyEndAllowThreads(__tstate);
30486 if (PyErr_Occurred()) SWIG_fail;
30487 }
30488 resultobj = SWIG_Py_Void();
30489 return resultobj;
30490 fail:
30491 return NULL;
30492 }
30493
30494
30495 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30496 PyObject *resultobj = 0;
30497 wxPyApp *arg1 = (wxPyApp *) 0 ;
30498 bool result;
30499 void *argp1 = 0 ;
30500 int res1 = 0 ;
30501 PyObject *swig_obj[1] ;
30502
30503 if (!args) SWIG_fail;
30504 swig_obj[0] = args;
30505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30506 if (!SWIG_IsOK(res1)) {
30507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
30508 }
30509 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30510 {
30511 PyThreadState* __tstate = wxPyBeginAllowThreads();
30512 result = (bool)(arg1)->Pending();
30513 wxPyEndAllowThreads(__tstate);
30514 if (PyErr_Occurred()) SWIG_fail;
30515 }
30516 {
30517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30518 }
30519 return resultobj;
30520 fail:
30521 return NULL;
30522 }
30523
30524
30525 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30526 PyObject *resultobj = 0;
30527 wxPyApp *arg1 = (wxPyApp *) 0 ;
30528 bool result;
30529 void *argp1 = 0 ;
30530 int res1 = 0 ;
30531 PyObject *swig_obj[1] ;
30532
30533 if (!args) SWIG_fail;
30534 swig_obj[0] = args;
30535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30536 if (!SWIG_IsOK(res1)) {
30537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
30538 }
30539 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30540 {
30541 PyThreadState* __tstate = wxPyBeginAllowThreads();
30542 result = (bool)(arg1)->Dispatch();
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_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30556 PyObject *resultobj = 0;
30557 wxPyApp *arg1 = (wxPyApp *) 0 ;
30558 bool result;
30559 void *argp1 = 0 ;
30560 int res1 = 0 ;
30561 PyObject *swig_obj[1] ;
30562
30563 if (!args) SWIG_fail;
30564 swig_obj[0] = args;
30565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30566 if (!SWIG_IsOK(res1)) {
30567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30568 }
30569 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30570 {
30571 PyThreadState* __tstate = wxPyBeginAllowThreads();
30572 result = (bool)(arg1)->ProcessIdle();
30573 wxPyEndAllowThreads(__tstate);
30574 if (PyErr_Occurred()) SWIG_fail;
30575 }
30576 {
30577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30578 }
30579 return resultobj;
30580 fail:
30581 return NULL;
30582 }
30583
30584
30585 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30586 PyObject *resultobj = 0;
30587 wxPyApp *arg1 = (wxPyApp *) 0 ;
30588 wxWindow *arg2 = (wxWindow *) 0 ;
30589 wxIdleEvent *arg3 = 0 ;
30590 bool result;
30591 void *argp1 = 0 ;
30592 int res1 = 0 ;
30593 void *argp2 = 0 ;
30594 int res2 = 0 ;
30595 void *argp3 = 0 ;
30596 int res3 = 0 ;
30597 PyObject * obj0 = 0 ;
30598 PyObject * obj1 = 0 ;
30599 PyObject * obj2 = 0 ;
30600 char * kwnames[] = {
30601 (char *) "self",(char *) "win",(char *) "event", NULL
30602 };
30603
30604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30606 if (!SWIG_IsOK(res1)) {
30607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30608 }
30609 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30610 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30611 if (!SWIG_IsOK(res2)) {
30612 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
30613 }
30614 arg2 = reinterpret_cast< wxWindow * >(argp2);
30615 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
30616 if (!SWIG_IsOK(res3)) {
30617 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30618 }
30619 if (!argp3) {
30620 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30621 }
30622 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
30623 {
30624 PyThreadState* __tstate = wxPyBeginAllowThreads();
30625 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
30626 wxPyEndAllowThreads(__tstate);
30627 if (PyErr_Occurred()) SWIG_fail;
30628 }
30629 {
30630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30631 }
30632 return resultobj;
30633 fail:
30634 return NULL;
30635 }
30636
30637
30638 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30639 PyObject *resultobj = 0;
30640 wxPyApp *arg1 = (wxPyApp *) 0 ;
30641 bool result;
30642 void *argp1 = 0 ;
30643 int res1 = 0 ;
30644 PyObject *swig_obj[1] ;
30645
30646 if (!args) SWIG_fail;
30647 swig_obj[0] = args;
30648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30649 if (!SWIG_IsOK(res1)) {
30650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30651 }
30652 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30653 {
30654 PyThreadState* __tstate = wxPyBeginAllowThreads();
30655 result = (bool)((wxPyApp const *)arg1)->IsActive();
30656 wxPyEndAllowThreads(__tstate);
30657 if (PyErr_Occurred()) SWIG_fail;
30658 }
30659 {
30660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30661 }
30662 return resultobj;
30663 fail:
30664 return NULL;
30665 }
30666
30667
30668 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30669 PyObject *resultobj = 0;
30670 wxPyApp *arg1 = (wxPyApp *) 0 ;
30671 wxWindow *arg2 = (wxWindow *) 0 ;
30672 void *argp1 = 0 ;
30673 int res1 = 0 ;
30674 void *argp2 = 0 ;
30675 int res2 = 0 ;
30676 PyObject * obj0 = 0 ;
30677 PyObject * obj1 = 0 ;
30678 char * kwnames[] = {
30679 (char *) "self",(char *) "win", NULL
30680 };
30681
30682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
30683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30684 if (!SWIG_IsOK(res1)) {
30685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
30686 }
30687 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30688 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30689 if (!SWIG_IsOK(res2)) {
30690 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
30691 }
30692 arg2 = reinterpret_cast< wxWindow * >(argp2);
30693 {
30694 PyThreadState* __tstate = wxPyBeginAllowThreads();
30695 (arg1)->SetTopWindow(arg2);
30696 wxPyEndAllowThreads(__tstate);
30697 if (PyErr_Occurred()) SWIG_fail;
30698 }
30699 resultobj = SWIG_Py_Void();
30700 return resultobj;
30701 fail:
30702 return NULL;
30703 }
30704
30705
30706 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30707 PyObject *resultobj = 0;
30708 wxPyApp *arg1 = (wxPyApp *) 0 ;
30709 wxWindow *result = 0 ;
30710 void *argp1 = 0 ;
30711 int res1 = 0 ;
30712 PyObject *swig_obj[1] ;
30713
30714 if (!args) SWIG_fail;
30715 swig_obj[0] = args;
30716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30717 if (!SWIG_IsOK(res1)) {
30718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30719 }
30720 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30721 {
30722 PyThreadState* __tstate = wxPyBeginAllowThreads();
30723 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
30724 wxPyEndAllowThreads(__tstate);
30725 if (PyErr_Occurred()) SWIG_fail;
30726 }
30727 {
30728 resultobj = wxPyMake_wxObject(result, (bool)0);
30729 }
30730 return resultobj;
30731 fail:
30732 return NULL;
30733 }
30734
30735
30736 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30737 PyObject *resultobj = 0;
30738 wxPyApp *arg1 = (wxPyApp *) 0 ;
30739 bool arg2 ;
30740 void *argp1 = 0 ;
30741 int res1 = 0 ;
30742 bool val2 ;
30743 int ecode2 = 0 ;
30744 PyObject * obj0 = 0 ;
30745 PyObject * obj1 = 0 ;
30746 char * kwnames[] = {
30747 (char *) "self",(char *) "flag", NULL
30748 };
30749
30750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
30751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30752 if (!SWIG_IsOK(res1)) {
30753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
30754 }
30755 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30756 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30757 if (!SWIG_IsOK(ecode2)) {
30758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
30759 }
30760 arg2 = static_cast< bool >(val2);
30761 {
30762 PyThreadState* __tstate = wxPyBeginAllowThreads();
30763 (arg1)->SetExitOnFrameDelete(arg2);
30764 wxPyEndAllowThreads(__tstate);
30765 if (PyErr_Occurred()) SWIG_fail;
30766 }
30767 resultobj = SWIG_Py_Void();
30768 return resultobj;
30769 fail:
30770 return NULL;
30771 }
30772
30773
30774 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30775 PyObject *resultobj = 0;
30776 wxPyApp *arg1 = (wxPyApp *) 0 ;
30777 bool result;
30778 void *argp1 = 0 ;
30779 int res1 = 0 ;
30780 PyObject *swig_obj[1] ;
30781
30782 if (!args) SWIG_fail;
30783 swig_obj[0] = args;
30784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30785 if (!SWIG_IsOK(res1)) {
30786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30787 }
30788 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30789 {
30790 PyThreadState* __tstate = wxPyBeginAllowThreads();
30791 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
30792 wxPyEndAllowThreads(__tstate);
30793 if (PyErr_Occurred()) SWIG_fail;
30794 }
30795 {
30796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30797 }
30798 return resultobj;
30799 fail:
30800 return NULL;
30801 }
30802
30803
30804 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30805 PyObject *resultobj = 0;
30806 wxPyApp *arg1 = (wxPyApp *) 0 ;
30807 bool arg2 ;
30808 void *argp1 = 0 ;
30809 int res1 = 0 ;
30810 bool val2 ;
30811 int ecode2 = 0 ;
30812 PyObject * obj0 = 0 ;
30813 PyObject * obj1 = 0 ;
30814 char * kwnames[] = {
30815 (char *) "self",(char *) "flag", NULL
30816 };
30817
30818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
30819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30820 if (!SWIG_IsOK(res1)) {
30821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
30822 }
30823 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30824 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30825 if (!SWIG_IsOK(ecode2)) {
30826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
30827 }
30828 arg2 = static_cast< bool >(val2);
30829 {
30830 PyThreadState* __tstate = wxPyBeginAllowThreads();
30831 (arg1)->SetUseBestVisual(arg2);
30832 wxPyEndAllowThreads(__tstate);
30833 if (PyErr_Occurred()) SWIG_fail;
30834 }
30835 resultobj = SWIG_Py_Void();
30836 return resultobj;
30837 fail:
30838 return NULL;
30839 }
30840
30841
30842 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30843 PyObject *resultobj = 0;
30844 wxPyApp *arg1 = (wxPyApp *) 0 ;
30845 bool result;
30846 void *argp1 = 0 ;
30847 int res1 = 0 ;
30848 PyObject *swig_obj[1] ;
30849
30850 if (!args) SWIG_fail;
30851 swig_obj[0] = args;
30852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30853 if (!SWIG_IsOK(res1)) {
30854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30855 }
30856 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30857 {
30858 PyThreadState* __tstate = wxPyBeginAllowThreads();
30859 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
30860 wxPyEndAllowThreads(__tstate);
30861 if (PyErr_Occurred()) SWIG_fail;
30862 }
30863 {
30864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30865 }
30866 return resultobj;
30867 fail:
30868 return NULL;
30869 }
30870
30871
30872 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30873 PyObject *resultobj = 0;
30874 wxPyApp *arg1 = (wxPyApp *) 0 ;
30875 int arg2 ;
30876 void *argp1 = 0 ;
30877 int res1 = 0 ;
30878 int val2 ;
30879 int ecode2 = 0 ;
30880 PyObject * obj0 = 0 ;
30881 PyObject * obj1 = 0 ;
30882 char * kwnames[] = {
30883 (char *) "self",(char *) "mode", NULL
30884 };
30885
30886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
30887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30888 if (!SWIG_IsOK(res1)) {
30889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30890 }
30891 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30892 ecode2 = SWIG_AsVal_int(obj1, &val2);
30893 if (!SWIG_IsOK(ecode2)) {
30894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
30895 }
30896 arg2 = static_cast< int >(val2);
30897 {
30898 PyThreadState* __tstate = wxPyBeginAllowThreads();
30899 (arg1)->SetPrintMode(arg2);
30900 wxPyEndAllowThreads(__tstate);
30901 if (PyErr_Occurred()) SWIG_fail;
30902 }
30903 resultobj = SWIG_Py_Void();
30904 return resultobj;
30905 fail:
30906 return NULL;
30907 }
30908
30909
30910 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30911 PyObject *resultobj = 0;
30912 wxPyApp *arg1 = (wxPyApp *) 0 ;
30913 int result;
30914 void *argp1 = 0 ;
30915 int res1 = 0 ;
30916 PyObject *swig_obj[1] ;
30917
30918 if (!args) SWIG_fail;
30919 swig_obj[0] = args;
30920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30921 if (!SWIG_IsOK(res1)) {
30922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30923 }
30924 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30925 {
30926 PyThreadState* __tstate = wxPyBeginAllowThreads();
30927 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
30928 wxPyEndAllowThreads(__tstate);
30929 if (PyErr_Occurred()) SWIG_fail;
30930 }
30931 resultobj = SWIG_From_int(static_cast< int >(result));
30932 return resultobj;
30933 fail:
30934 return NULL;
30935 }
30936
30937
30938 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30939 PyObject *resultobj = 0;
30940 wxPyApp *arg1 = (wxPyApp *) 0 ;
30941 int arg2 ;
30942 void *argp1 = 0 ;
30943 int res1 = 0 ;
30944 int val2 ;
30945 int ecode2 = 0 ;
30946 PyObject * obj0 = 0 ;
30947 PyObject * obj1 = 0 ;
30948 char * kwnames[] = {
30949 (char *) "self",(char *) "mode", NULL
30950 };
30951
30952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
30953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30954 if (!SWIG_IsOK(res1)) {
30955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30956 }
30957 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30958 ecode2 = SWIG_AsVal_int(obj1, &val2);
30959 if (!SWIG_IsOK(ecode2)) {
30960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
30961 }
30962 arg2 = static_cast< int >(val2);
30963 {
30964 PyThreadState* __tstate = wxPyBeginAllowThreads();
30965 (arg1)->SetAssertMode(arg2);
30966 wxPyEndAllowThreads(__tstate);
30967 if (PyErr_Occurred()) SWIG_fail;
30968 }
30969 resultobj = SWIG_Py_Void();
30970 return resultobj;
30971 fail:
30972 return NULL;
30973 }
30974
30975
30976 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30977 PyObject *resultobj = 0;
30978 wxPyApp *arg1 = (wxPyApp *) 0 ;
30979 int result;
30980 void *argp1 = 0 ;
30981 int res1 = 0 ;
30982 PyObject *swig_obj[1] ;
30983
30984 if (!args) SWIG_fail;
30985 swig_obj[0] = args;
30986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30987 if (!SWIG_IsOK(res1)) {
30988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30989 }
30990 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30991 {
30992 PyThreadState* __tstate = wxPyBeginAllowThreads();
30993 result = (int)(arg1)->GetAssertMode();
30994 wxPyEndAllowThreads(__tstate);
30995 if (PyErr_Occurred()) SWIG_fail;
30996 }
30997 resultobj = SWIG_From_int(static_cast< int >(result));
30998 return resultobj;
30999 fail:
31000 return NULL;
31001 }
31002
31003
31004 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31005 PyObject *resultobj = 0;
31006 bool result;
31007
31008 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
31009 {
31010 PyThreadState* __tstate = wxPyBeginAllowThreads();
31011 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
31012 wxPyEndAllowThreads(__tstate);
31013 if (PyErr_Occurred()) SWIG_fail;
31014 }
31015 {
31016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31017 }
31018 return resultobj;
31019 fail:
31020 return NULL;
31021 }
31022
31023
31024 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31025 PyObject *resultobj = 0;
31026 long result;
31027
31028 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
31029 {
31030 PyThreadState* __tstate = wxPyBeginAllowThreads();
31031 result = (long)wxPyApp::GetMacAboutMenuItemId();
31032 wxPyEndAllowThreads(__tstate);
31033 if (PyErr_Occurred()) SWIG_fail;
31034 }
31035 resultobj = SWIG_From_long(static_cast< long >(result));
31036 return resultobj;
31037 fail:
31038 return NULL;
31039 }
31040
31041
31042 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31043 PyObject *resultobj = 0;
31044 long result;
31045
31046 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
31047 {
31048 PyThreadState* __tstate = wxPyBeginAllowThreads();
31049 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
31050 wxPyEndAllowThreads(__tstate);
31051 if (PyErr_Occurred()) SWIG_fail;
31052 }
31053 resultobj = SWIG_From_long(static_cast< long >(result));
31054 return resultobj;
31055 fail:
31056 return NULL;
31057 }
31058
31059
31060 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31061 PyObject *resultobj = 0;
31062 long result;
31063
31064 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
31065 {
31066 PyThreadState* __tstate = wxPyBeginAllowThreads();
31067 result = (long)wxPyApp::GetMacExitMenuItemId();
31068 wxPyEndAllowThreads(__tstate);
31069 if (PyErr_Occurred()) SWIG_fail;
31070 }
31071 resultobj = SWIG_From_long(static_cast< long >(result));
31072 return resultobj;
31073 fail:
31074 return NULL;
31075 }
31076
31077
31078 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31079 PyObject *resultobj = 0;
31080 wxString result;
31081
31082 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
31083 {
31084 PyThreadState* __tstate = wxPyBeginAllowThreads();
31085 result = wxPyApp::GetMacHelpMenuTitleName();
31086 wxPyEndAllowThreads(__tstate);
31087 if (PyErr_Occurred()) SWIG_fail;
31088 }
31089 {
31090 #if wxUSE_UNICODE
31091 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31092 #else
31093 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31094 #endif
31095 }
31096 return resultobj;
31097 fail:
31098 return NULL;
31099 }
31100
31101
31102 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31103 PyObject *resultobj = 0;
31104 bool arg1 ;
31105 bool val1 ;
31106 int ecode1 = 0 ;
31107 PyObject * obj0 = 0 ;
31108 char * kwnames[] = {
31109 (char *) "val", NULL
31110 };
31111
31112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
31113 ecode1 = SWIG_AsVal_bool(obj0, &val1);
31114 if (!SWIG_IsOK(ecode1)) {
31115 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
31116 }
31117 arg1 = static_cast< bool >(val1);
31118 {
31119 PyThreadState* __tstate = wxPyBeginAllowThreads();
31120 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
31121 wxPyEndAllowThreads(__tstate);
31122 if (PyErr_Occurred()) SWIG_fail;
31123 }
31124 resultobj = SWIG_Py_Void();
31125 return resultobj;
31126 fail:
31127 return NULL;
31128 }
31129
31130
31131 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31132 PyObject *resultobj = 0;
31133 long arg1 ;
31134 long val1 ;
31135 int ecode1 = 0 ;
31136 PyObject * obj0 = 0 ;
31137 char * kwnames[] = {
31138 (char *) "val", NULL
31139 };
31140
31141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
31142 ecode1 = SWIG_AsVal_long(obj0, &val1);
31143 if (!SWIG_IsOK(ecode1)) {
31144 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
31145 }
31146 arg1 = static_cast< long >(val1);
31147 {
31148 PyThreadState* __tstate = wxPyBeginAllowThreads();
31149 wxPyApp::SetMacAboutMenuItemId(arg1);
31150 wxPyEndAllowThreads(__tstate);
31151 if (PyErr_Occurred()) SWIG_fail;
31152 }
31153 resultobj = SWIG_Py_Void();
31154 return resultobj;
31155 fail:
31156 return NULL;
31157 }
31158
31159
31160 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31161 PyObject *resultobj = 0;
31162 long arg1 ;
31163 long val1 ;
31164 int ecode1 = 0 ;
31165 PyObject * obj0 = 0 ;
31166 char * kwnames[] = {
31167 (char *) "val", NULL
31168 };
31169
31170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
31171 ecode1 = SWIG_AsVal_long(obj0, &val1);
31172 if (!SWIG_IsOK(ecode1)) {
31173 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
31174 }
31175 arg1 = static_cast< long >(val1);
31176 {
31177 PyThreadState* __tstate = wxPyBeginAllowThreads();
31178 wxPyApp::SetMacPreferencesMenuItemId(arg1);
31179 wxPyEndAllowThreads(__tstate);
31180 if (PyErr_Occurred()) SWIG_fail;
31181 }
31182 resultobj = SWIG_Py_Void();
31183 return resultobj;
31184 fail:
31185 return NULL;
31186 }
31187
31188
31189 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31190 PyObject *resultobj = 0;
31191 long arg1 ;
31192 long val1 ;
31193 int ecode1 = 0 ;
31194 PyObject * obj0 = 0 ;
31195 char * kwnames[] = {
31196 (char *) "val", NULL
31197 };
31198
31199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
31200 ecode1 = SWIG_AsVal_long(obj0, &val1);
31201 if (!SWIG_IsOK(ecode1)) {
31202 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
31203 }
31204 arg1 = static_cast< long >(val1);
31205 {
31206 PyThreadState* __tstate = wxPyBeginAllowThreads();
31207 wxPyApp::SetMacExitMenuItemId(arg1);
31208 wxPyEndAllowThreads(__tstate);
31209 if (PyErr_Occurred()) SWIG_fail;
31210 }
31211 resultobj = SWIG_Py_Void();
31212 return resultobj;
31213 fail:
31214 return NULL;
31215 }
31216
31217
31218 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31219 PyObject *resultobj = 0;
31220 wxString *arg1 = 0 ;
31221 bool temp1 = false ;
31222 PyObject * obj0 = 0 ;
31223 char * kwnames[] = {
31224 (char *) "val", NULL
31225 };
31226
31227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
31228 {
31229 arg1 = wxString_in_helper(obj0);
31230 if (arg1 == NULL) SWIG_fail;
31231 temp1 = true;
31232 }
31233 {
31234 PyThreadState* __tstate = wxPyBeginAllowThreads();
31235 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
31236 wxPyEndAllowThreads(__tstate);
31237 if (PyErr_Occurred()) SWIG_fail;
31238 }
31239 resultobj = SWIG_Py_Void();
31240 {
31241 if (temp1)
31242 delete arg1;
31243 }
31244 return resultobj;
31245 fail:
31246 {
31247 if (temp1)
31248 delete arg1;
31249 }
31250 return NULL;
31251 }
31252
31253
31254 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31255 PyObject *resultobj = 0;
31256 wxPyApp *arg1 = (wxPyApp *) 0 ;
31257 void *argp1 = 0 ;
31258 int res1 = 0 ;
31259 PyObject *swig_obj[1] ;
31260
31261 if (!args) SWIG_fail;
31262 swig_obj[0] = args;
31263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31264 if (!SWIG_IsOK(res1)) {
31265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
31266 }
31267 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31268 {
31269 PyThreadState* __tstate = wxPyBeginAllowThreads();
31270 (arg1)->_BootstrapApp();
31271 wxPyEndAllowThreads(__tstate);
31272 if (PyErr_Occurred()) SWIG_fail;
31273 }
31274 resultobj = SWIG_Py_Void();
31275 return resultobj;
31276 fail:
31277 return NULL;
31278 }
31279
31280
31281 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31282 PyObject *resultobj = 0;
31283 int result;
31284
31285 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
31286 {
31287 PyThreadState* __tstate = wxPyBeginAllowThreads();
31288 result = (int)wxPyApp_GetComCtl32Version();
31289 wxPyEndAllowThreads(__tstate);
31290 if (PyErr_Occurred()) SWIG_fail;
31291 }
31292 resultobj = SWIG_From_int(static_cast< int >(result));
31293 return resultobj;
31294 fail:
31295 return NULL;
31296 }
31297
31298
31299 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31300 PyObject *resultobj = 0;
31301 bool result;
31302
31303 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
31304 {
31305 PyThreadState* __tstate = wxPyBeginAllowThreads();
31306 result = (bool)wxPyApp_IsDisplayAvailable();
31307 wxPyEndAllowThreads(__tstate);
31308 if (PyErr_Occurred()) SWIG_fail;
31309 }
31310 {
31311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31312 }
31313 return resultobj;
31314 fail:
31315 return NULL;
31316 }
31317
31318
31319 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31320 PyObject *obj;
31321 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31322 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
31323 return SWIG_Py_Void();
31324 }
31325
31326 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31327 return SWIG_Python_InitShadowInstance(args);
31328 }
31329
31330 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31331 PyObject *resultobj = 0;
31332
31333 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
31334 {
31335 PyThreadState* __tstate = wxPyBeginAllowThreads();
31336 wxExit();
31337 wxPyEndAllowThreads(__tstate);
31338 if (PyErr_Occurred()) SWIG_fail;
31339 }
31340 resultobj = SWIG_Py_Void();
31341 return resultobj;
31342 fail:
31343 return NULL;
31344 }
31345
31346
31347 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31348 PyObject *resultobj = 0;
31349 bool result;
31350
31351 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
31352 {
31353 PyThreadState* __tstate = wxPyBeginAllowThreads();
31354 result = (bool)wxYield();
31355 wxPyEndAllowThreads(__tstate);
31356 if (PyErr_Occurred()) SWIG_fail;
31357 }
31358 {
31359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31360 }
31361 return resultobj;
31362 fail:
31363 return NULL;
31364 }
31365
31366
31367 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31368 PyObject *resultobj = 0;
31369 bool result;
31370
31371 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
31372 {
31373 PyThreadState* __tstate = wxPyBeginAllowThreads();
31374 result = (bool)wxYieldIfNeeded();
31375 wxPyEndAllowThreads(__tstate);
31376 if (PyErr_Occurred()) SWIG_fail;
31377 }
31378 {
31379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31380 }
31381 return resultobj;
31382 fail:
31383 return NULL;
31384 }
31385
31386
31387 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31388 PyObject *resultobj = 0;
31389 wxWindow *arg1 = (wxWindow *) NULL ;
31390 bool arg2 = (bool) false ;
31391 bool result;
31392 void *argp1 = 0 ;
31393 int res1 = 0 ;
31394 bool val2 ;
31395 int ecode2 = 0 ;
31396 PyObject * obj0 = 0 ;
31397 PyObject * obj1 = 0 ;
31398 char * kwnames[] = {
31399 (char *) "win",(char *) "onlyIfNeeded", NULL
31400 };
31401
31402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
31403 if (obj0) {
31404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31405 if (!SWIG_IsOK(res1)) {
31406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
31407 }
31408 arg1 = reinterpret_cast< wxWindow * >(argp1);
31409 }
31410 if (obj1) {
31411 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31412 if (!SWIG_IsOK(ecode2)) {
31413 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
31414 }
31415 arg2 = static_cast< bool >(val2);
31416 }
31417 {
31418 PyThreadState* __tstate = wxPyBeginAllowThreads();
31419 result = (bool)wxSafeYield(arg1,arg2);
31420 wxPyEndAllowThreads(__tstate);
31421 if (PyErr_Occurred()) SWIG_fail;
31422 }
31423 {
31424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31425 }
31426 return resultobj;
31427 fail:
31428 return NULL;
31429 }
31430
31431
31432 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31433 PyObject *resultobj = 0;
31434
31435 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
31436 {
31437 PyThreadState* __tstate = wxPyBeginAllowThreads();
31438 wxWakeUpIdle();
31439 wxPyEndAllowThreads(__tstate);
31440 if (PyErr_Occurred()) SWIG_fail;
31441 }
31442 resultobj = SWIG_Py_Void();
31443 return resultobj;
31444 fail:
31445 return NULL;
31446 }
31447
31448
31449 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31450 PyObject *resultobj = 0;
31451 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
31452 wxEvent *arg2 = 0 ;
31453 void *argp1 = 0 ;
31454 int res1 = 0 ;
31455 void *argp2 = 0 ;
31456 int res2 = 0 ;
31457 PyObject * obj0 = 0 ;
31458 PyObject * obj1 = 0 ;
31459 char * kwnames[] = {
31460 (char *) "dest",(char *) "event", NULL
31461 };
31462
31463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
31464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
31465 if (!SWIG_IsOK(res1)) {
31466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
31467 }
31468 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
31469 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
31470 if (!SWIG_IsOK(res2)) {
31471 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31472 }
31473 if (!argp2) {
31474 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31475 }
31476 arg2 = reinterpret_cast< wxEvent * >(argp2);
31477 {
31478 PyThreadState* __tstate = wxPyBeginAllowThreads();
31479 wxPostEvent(arg1,*arg2);
31480 wxPyEndAllowThreads(__tstate);
31481 if (PyErr_Occurred()) SWIG_fail;
31482 }
31483 resultobj = SWIG_Py_Void();
31484 return resultobj;
31485 fail:
31486 return NULL;
31487 }
31488
31489
31490 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31491 PyObject *resultobj = 0;
31492
31493 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
31494 {
31495 PyThreadState* __tstate = wxPyBeginAllowThreads();
31496 wxApp_CleanUp();
31497 wxPyEndAllowThreads(__tstate);
31498 if (PyErr_Occurred()) SWIG_fail;
31499 }
31500 resultobj = SWIG_Py_Void();
31501 return resultobj;
31502 fail:
31503 return NULL;
31504 }
31505
31506
31507 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31508 PyObject *resultobj = 0;
31509 wxPyApp *result = 0 ;
31510
31511 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
31512 {
31513 PyThreadState* __tstate = wxPyBeginAllowThreads();
31514 result = (wxPyApp *)wxPyGetApp();
31515 wxPyEndAllowThreads(__tstate);
31516 if (PyErr_Occurred()) SWIG_fail;
31517 }
31518 {
31519 resultobj = wxPyMake_wxObject(result, 0);
31520 }
31521 return resultobj;
31522 fail:
31523 return NULL;
31524 }
31525
31526
31527 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31528 PyObject *resultobj = 0;
31529 char *arg1 = (char *) 0 ;
31530 int res1 ;
31531 char *buf1 = 0 ;
31532 int alloc1 = 0 ;
31533 PyObject * obj0 = 0 ;
31534 char * kwnames[] = {
31535 (char *) "encoding", NULL
31536 };
31537
31538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
31539 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
31540 if (!SWIG_IsOK(res1)) {
31541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
31542 }
31543 arg1 = buf1;
31544 {
31545 PyThreadState* __tstate = wxPyBeginAllowThreads();
31546 wxSetDefaultPyEncoding((char const *)arg1);
31547 wxPyEndAllowThreads(__tstate);
31548 if (PyErr_Occurred()) SWIG_fail;
31549 }
31550 resultobj = SWIG_Py_Void();
31551 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31552 return resultobj;
31553 fail:
31554 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31555 return NULL;
31556 }
31557
31558
31559 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31560 PyObject *resultobj = 0;
31561 char *result = 0 ;
31562
31563 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
31564 {
31565 PyThreadState* __tstate = wxPyBeginAllowThreads();
31566 result = (char *)wxGetDefaultPyEncoding();
31567 wxPyEndAllowThreads(__tstate);
31568 if (PyErr_Occurred()) SWIG_fail;
31569 }
31570 resultobj = SWIG_FromCharPtr(result);
31571 return resultobj;
31572 fail:
31573 return NULL;
31574 }
31575
31576
31577 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31578 PyObject *resultobj = 0;
31579 wxEventLoop *result = 0 ;
31580
31581 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
31582 {
31583 PyThreadState* __tstate = wxPyBeginAllowThreads();
31584 result = (wxEventLoop *)new wxEventLoop();
31585 wxPyEndAllowThreads(__tstate);
31586 if (PyErr_Occurred()) SWIG_fail;
31587 }
31588 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
31589 return resultobj;
31590 fail:
31591 return NULL;
31592 }
31593
31594
31595 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31596 PyObject *resultobj = 0;
31597 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31598 void *argp1 = 0 ;
31599 int res1 = 0 ;
31600 PyObject *swig_obj[1] ;
31601
31602 if (!args) SWIG_fail;
31603 swig_obj[0] = args;
31604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
31605 if (!SWIG_IsOK(res1)) {
31606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31607 }
31608 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31609 {
31610 PyThreadState* __tstate = wxPyBeginAllowThreads();
31611 delete arg1;
31612
31613 wxPyEndAllowThreads(__tstate);
31614 if (PyErr_Occurred()) SWIG_fail;
31615 }
31616 resultobj = SWIG_Py_Void();
31617 return resultobj;
31618 fail:
31619 return NULL;
31620 }
31621
31622
31623 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31624 PyObject *resultobj = 0;
31625 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31626 int result;
31627 void *argp1 = 0 ;
31628 int res1 = 0 ;
31629 PyObject *swig_obj[1] ;
31630
31631 if (!args) SWIG_fail;
31632 swig_obj[0] = args;
31633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31634 if (!SWIG_IsOK(res1)) {
31635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31636 }
31637 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31638 {
31639 PyThreadState* __tstate = wxPyBeginAllowThreads();
31640 result = (int)(arg1)->Run();
31641 wxPyEndAllowThreads(__tstate);
31642 if (PyErr_Occurred()) SWIG_fail;
31643 }
31644 resultobj = SWIG_From_int(static_cast< int >(result));
31645 return resultobj;
31646 fail:
31647 return NULL;
31648 }
31649
31650
31651 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31652 PyObject *resultobj = 0;
31653 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31654 int arg2 = (int) 0 ;
31655 void *argp1 = 0 ;
31656 int res1 = 0 ;
31657 int val2 ;
31658 int ecode2 = 0 ;
31659 PyObject * obj0 = 0 ;
31660 PyObject * obj1 = 0 ;
31661 char * kwnames[] = {
31662 (char *) "self",(char *) "rc", NULL
31663 };
31664
31665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
31666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31667 if (!SWIG_IsOK(res1)) {
31668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31669 }
31670 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31671 if (obj1) {
31672 ecode2 = SWIG_AsVal_int(obj1, &val2);
31673 if (!SWIG_IsOK(ecode2)) {
31674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
31675 }
31676 arg2 = static_cast< int >(val2);
31677 }
31678 {
31679 PyThreadState* __tstate = wxPyBeginAllowThreads();
31680 (arg1)->Exit(arg2);
31681 wxPyEndAllowThreads(__tstate);
31682 if (PyErr_Occurred()) SWIG_fail;
31683 }
31684 resultobj = SWIG_Py_Void();
31685 return resultobj;
31686 fail:
31687 return NULL;
31688 }
31689
31690
31691 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31692 PyObject *resultobj = 0;
31693 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31694 bool result;
31695 void *argp1 = 0 ;
31696 int res1 = 0 ;
31697 PyObject *swig_obj[1] ;
31698
31699 if (!args) SWIG_fail;
31700 swig_obj[0] = args;
31701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31702 if (!SWIG_IsOK(res1)) {
31703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31704 }
31705 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31706 {
31707 PyThreadState* __tstate = wxPyBeginAllowThreads();
31708 result = (bool)((wxEventLoop const *)arg1)->Pending();
31709 wxPyEndAllowThreads(__tstate);
31710 if (PyErr_Occurred()) SWIG_fail;
31711 }
31712 {
31713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31714 }
31715 return resultobj;
31716 fail:
31717 return NULL;
31718 }
31719
31720
31721 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31722 PyObject *resultobj = 0;
31723 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31724 bool result;
31725 void *argp1 = 0 ;
31726 int res1 = 0 ;
31727 PyObject *swig_obj[1] ;
31728
31729 if (!args) SWIG_fail;
31730 swig_obj[0] = args;
31731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31732 if (!SWIG_IsOK(res1)) {
31733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31734 }
31735 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31736 {
31737 PyThreadState* __tstate = wxPyBeginAllowThreads();
31738 result = (bool)(arg1)->Dispatch();
31739 wxPyEndAllowThreads(__tstate);
31740 if (PyErr_Occurred()) SWIG_fail;
31741 }
31742 {
31743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31744 }
31745 return resultobj;
31746 fail:
31747 return NULL;
31748 }
31749
31750
31751 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31752 PyObject *resultobj = 0;
31753 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31754 bool result;
31755 void *argp1 = 0 ;
31756 int res1 = 0 ;
31757 PyObject *swig_obj[1] ;
31758
31759 if (!args) SWIG_fail;
31760 swig_obj[0] = args;
31761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31762 if (!SWIG_IsOK(res1)) {
31763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31764 }
31765 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31766 {
31767 PyThreadState* __tstate = wxPyBeginAllowThreads();
31768 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
31769 wxPyEndAllowThreads(__tstate);
31770 if (PyErr_Occurred()) SWIG_fail;
31771 }
31772 {
31773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31774 }
31775 return resultobj;
31776 fail:
31777 return NULL;
31778 }
31779
31780
31781 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31782 PyObject *resultobj = 0;
31783 wxEventLoop *result = 0 ;
31784
31785 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
31786 {
31787 PyThreadState* __tstate = wxPyBeginAllowThreads();
31788 result = (wxEventLoop *)wxEventLoop::GetActive();
31789 wxPyEndAllowThreads(__tstate);
31790 if (PyErr_Occurred()) SWIG_fail;
31791 }
31792 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
31793 return resultobj;
31794 fail:
31795 return NULL;
31796 }
31797
31798
31799 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31800 PyObject *resultobj = 0;
31801 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31802 void *argp1 = 0 ;
31803 int res1 = 0 ;
31804 PyObject * obj0 = 0 ;
31805 char * kwnames[] = {
31806 (char *) "loop", NULL
31807 };
31808
31809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
31810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31811 if (!SWIG_IsOK(res1)) {
31812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31813 }
31814 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31815 {
31816 PyThreadState* __tstate = wxPyBeginAllowThreads();
31817 wxEventLoop::SetActive(arg1);
31818 wxPyEndAllowThreads(__tstate);
31819 if (PyErr_Occurred()) SWIG_fail;
31820 }
31821 resultobj = SWIG_Py_Void();
31822 return resultobj;
31823 fail:
31824 return NULL;
31825 }
31826
31827
31828 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31829 PyObject *obj;
31830 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31831 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
31832 return SWIG_Py_Void();
31833 }
31834
31835 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31836 return SWIG_Python_InitShadowInstance(args);
31837 }
31838
31839 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31840 PyObject *resultobj = 0;
31841 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31842 wxEventLoopActivator *result = 0 ;
31843 void *argp1 = 0 ;
31844 int res1 = 0 ;
31845 PyObject * obj0 = 0 ;
31846 char * kwnames[] = {
31847 (char *) "evtLoop", NULL
31848 };
31849
31850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
31851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31852 if (!SWIG_IsOK(res1)) {
31853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31854 }
31855 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31856 {
31857 PyThreadState* __tstate = wxPyBeginAllowThreads();
31858 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
31859 wxPyEndAllowThreads(__tstate);
31860 if (PyErr_Occurred()) SWIG_fail;
31861 }
31862 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
31863 return resultobj;
31864 fail:
31865 return NULL;
31866 }
31867
31868
31869 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31870 PyObject *resultobj = 0;
31871 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
31872 void *argp1 = 0 ;
31873 int res1 = 0 ;
31874 PyObject *swig_obj[1] ;
31875
31876 if (!args) SWIG_fail;
31877 swig_obj[0] = args;
31878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
31879 if (!SWIG_IsOK(res1)) {
31880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
31881 }
31882 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
31883 {
31884 PyThreadState* __tstate = wxPyBeginAllowThreads();
31885 delete arg1;
31886
31887 wxPyEndAllowThreads(__tstate);
31888 if (PyErr_Occurred()) SWIG_fail;
31889 }
31890 resultobj = SWIG_Py_Void();
31891 return resultobj;
31892 fail:
31893 return NULL;
31894 }
31895
31896
31897 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31898 PyObject *obj;
31899 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31900 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
31901 return SWIG_Py_Void();
31902 }
31903
31904 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31905 return SWIG_Python_InitShadowInstance(args);
31906 }
31907
31908 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31909 PyObject *resultobj = 0;
31910 int arg1 = (int) 0 ;
31911 int arg2 = (int) 0 ;
31912 int arg3 = (int) 0 ;
31913 wxAcceleratorEntry *result = 0 ;
31914 int val1 ;
31915 int ecode1 = 0 ;
31916 int val2 ;
31917 int ecode2 = 0 ;
31918 int val3 ;
31919 int ecode3 = 0 ;
31920 PyObject * obj0 = 0 ;
31921 PyObject * obj1 = 0 ;
31922 PyObject * obj2 = 0 ;
31923 char * kwnames[] = {
31924 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
31925 };
31926
31927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31928 if (obj0) {
31929 ecode1 = SWIG_AsVal_int(obj0, &val1);
31930 if (!SWIG_IsOK(ecode1)) {
31931 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
31932 }
31933 arg1 = static_cast< int >(val1);
31934 }
31935 if (obj1) {
31936 ecode2 = SWIG_AsVal_int(obj1, &val2);
31937 if (!SWIG_IsOK(ecode2)) {
31938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
31939 }
31940 arg2 = static_cast< int >(val2);
31941 }
31942 if (obj2) {
31943 ecode3 = SWIG_AsVal_int(obj2, &val3);
31944 if (!SWIG_IsOK(ecode3)) {
31945 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
31946 }
31947 arg3 = static_cast< int >(val3);
31948 }
31949 {
31950 PyThreadState* __tstate = wxPyBeginAllowThreads();
31951 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
31952 wxPyEndAllowThreads(__tstate);
31953 if (PyErr_Occurred()) SWIG_fail;
31954 }
31955 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
31956 return resultobj;
31957 fail:
31958 return NULL;
31959 }
31960
31961
31962 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31963 PyObject *resultobj = 0;
31964 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
31965 void *argp1 = 0 ;
31966 int res1 = 0 ;
31967 PyObject *swig_obj[1] ;
31968
31969 if (!args) SWIG_fail;
31970 swig_obj[0] = args;
31971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
31972 if (!SWIG_IsOK(res1)) {
31973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
31974 }
31975 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
31976 {
31977 PyThreadState* __tstate = wxPyBeginAllowThreads();
31978 delete arg1;
31979
31980 wxPyEndAllowThreads(__tstate);
31981 if (PyErr_Occurred()) SWIG_fail;
31982 }
31983 resultobj = SWIG_Py_Void();
31984 return resultobj;
31985 fail:
31986 return NULL;
31987 }
31988
31989
31990 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31991 PyObject *resultobj = 0;
31992 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
31993 int arg2 ;
31994 int arg3 ;
31995 int arg4 ;
31996 void *argp1 = 0 ;
31997 int res1 = 0 ;
31998 int val2 ;
31999 int ecode2 = 0 ;
32000 int val3 ;
32001 int ecode3 = 0 ;
32002 int val4 ;
32003 int ecode4 = 0 ;
32004 PyObject * obj0 = 0 ;
32005 PyObject * obj1 = 0 ;
32006 PyObject * obj2 = 0 ;
32007 PyObject * obj3 = 0 ;
32008 char * kwnames[] = {
32009 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
32010 };
32011
32012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32014 if (!SWIG_IsOK(res1)) {
32015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32016 }
32017 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32018 ecode2 = SWIG_AsVal_int(obj1, &val2);
32019 if (!SWIG_IsOK(ecode2)) {
32020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
32021 }
32022 arg2 = static_cast< int >(val2);
32023 ecode3 = SWIG_AsVal_int(obj2, &val3);
32024 if (!SWIG_IsOK(ecode3)) {
32025 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
32026 }
32027 arg3 = static_cast< int >(val3);
32028 ecode4 = SWIG_AsVal_int(obj3, &val4);
32029 if (!SWIG_IsOK(ecode4)) {
32030 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
32031 }
32032 arg4 = static_cast< int >(val4);
32033 {
32034 PyThreadState* __tstate = wxPyBeginAllowThreads();
32035 (arg1)->Set(arg2,arg3,arg4);
32036 wxPyEndAllowThreads(__tstate);
32037 if (PyErr_Occurred()) SWIG_fail;
32038 }
32039 resultobj = SWIG_Py_Void();
32040 return resultobj;
32041 fail:
32042 return NULL;
32043 }
32044
32045
32046 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32047 PyObject *resultobj = 0;
32048 wxString *arg1 = 0 ;
32049 wxAcceleratorEntry *result = 0 ;
32050 bool temp1 = false ;
32051 PyObject * obj0 = 0 ;
32052 char * kwnames[] = {
32053 (char *) "str", NULL
32054 };
32055
32056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
32057 {
32058 arg1 = wxString_in_helper(obj0);
32059 if (arg1 == NULL) SWIG_fail;
32060 temp1 = true;
32061 }
32062 {
32063 PyThreadState* __tstate = wxPyBeginAllowThreads();
32064 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
32065 wxPyEndAllowThreads(__tstate);
32066 if (PyErr_Occurred()) SWIG_fail;
32067 }
32068 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
32069 {
32070 if (temp1)
32071 delete arg1;
32072 }
32073 return resultobj;
32074 fail:
32075 {
32076 if (temp1)
32077 delete arg1;
32078 }
32079 return NULL;
32080 }
32081
32082
32083 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32084 PyObject *resultobj = 0;
32085 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32086 int result;
32087 void *argp1 = 0 ;
32088 int res1 = 0 ;
32089 PyObject *swig_obj[1] ;
32090
32091 if (!args) SWIG_fail;
32092 swig_obj[0] = args;
32093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32094 if (!SWIG_IsOK(res1)) {
32095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32096 }
32097 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32098 {
32099 PyThreadState* __tstate = wxPyBeginAllowThreads();
32100 result = (int)(arg1)->GetFlags();
32101 wxPyEndAllowThreads(__tstate);
32102 if (PyErr_Occurred()) SWIG_fail;
32103 }
32104 resultobj = SWIG_From_int(static_cast< int >(result));
32105 return resultobj;
32106 fail:
32107 return NULL;
32108 }
32109
32110
32111 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32112 PyObject *resultobj = 0;
32113 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32114 int result;
32115 void *argp1 = 0 ;
32116 int res1 = 0 ;
32117 PyObject *swig_obj[1] ;
32118
32119 if (!args) SWIG_fail;
32120 swig_obj[0] = args;
32121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32122 if (!SWIG_IsOK(res1)) {
32123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32124 }
32125 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32126 {
32127 PyThreadState* __tstate = wxPyBeginAllowThreads();
32128 result = (int)(arg1)->GetKeyCode();
32129 wxPyEndAllowThreads(__tstate);
32130 if (PyErr_Occurred()) SWIG_fail;
32131 }
32132 resultobj = SWIG_From_int(static_cast< int >(result));
32133 return resultobj;
32134 fail:
32135 return NULL;
32136 }
32137
32138
32139 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32140 PyObject *resultobj = 0;
32141 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32142 int result;
32143 void *argp1 = 0 ;
32144 int res1 = 0 ;
32145 PyObject *swig_obj[1] ;
32146
32147 if (!args) SWIG_fail;
32148 swig_obj[0] = args;
32149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32150 if (!SWIG_IsOK(res1)) {
32151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32152 }
32153 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32154 {
32155 PyThreadState* __tstate = wxPyBeginAllowThreads();
32156 result = (int)(arg1)->GetCommand();
32157 wxPyEndAllowThreads(__tstate);
32158 if (PyErr_Occurred()) SWIG_fail;
32159 }
32160 resultobj = SWIG_From_int(static_cast< int >(result));
32161 return resultobj;
32162 fail:
32163 return NULL;
32164 }
32165
32166
32167 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32168 PyObject *resultobj = 0;
32169 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32170 bool result;
32171 void *argp1 = 0 ;
32172 int res1 = 0 ;
32173 PyObject *swig_obj[1] ;
32174
32175 if (!args) SWIG_fail;
32176 swig_obj[0] = args;
32177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32178 if (!SWIG_IsOK(res1)) {
32179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32180 }
32181 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32182 {
32183 PyThreadState* __tstate = wxPyBeginAllowThreads();
32184 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
32185 wxPyEndAllowThreads(__tstate);
32186 if (PyErr_Occurred()) SWIG_fail;
32187 }
32188 {
32189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32190 }
32191 return resultobj;
32192 fail:
32193 return NULL;
32194 }
32195
32196
32197 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32198 PyObject *resultobj = 0;
32199 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32200 wxString result;
32201 void *argp1 = 0 ;
32202 int res1 = 0 ;
32203 PyObject *swig_obj[1] ;
32204
32205 if (!args) SWIG_fail;
32206 swig_obj[0] = args;
32207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32208 if (!SWIG_IsOK(res1)) {
32209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32210 }
32211 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32212 {
32213 PyThreadState* __tstate = wxPyBeginAllowThreads();
32214 result = ((wxAcceleratorEntry const *)arg1)->ToString();
32215 wxPyEndAllowThreads(__tstate);
32216 if (PyErr_Occurred()) SWIG_fail;
32217 }
32218 {
32219 #if wxUSE_UNICODE
32220 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32221 #else
32222 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32223 #endif
32224 }
32225 return resultobj;
32226 fail:
32227 return NULL;
32228 }
32229
32230
32231 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32232 PyObject *resultobj = 0;
32233 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32234 wxString *arg2 = 0 ;
32235 bool result;
32236 void *argp1 = 0 ;
32237 int res1 = 0 ;
32238 bool temp2 = false ;
32239 PyObject * obj0 = 0 ;
32240 PyObject * obj1 = 0 ;
32241 char * kwnames[] = {
32242 (char *) "self",(char *) "str", NULL
32243 };
32244
32245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
32246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32247 if (!SWIG_IsOK(res1)) {
32248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32249 }
32250 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32251 {
32252 arg2 = wxString_in_helper(obj1);
32253 if (arg2 == NULL) SWIG_fail;
32254 temp2 = true;
32255 }
32256 {
32257 PyThreadState* __tstate = wxPyBeginAllowThreads();
32258 result = (bool)(arg1)->FromString((wxString const &)*arg2);
32259 wxPyEndAllowThreads(__tstate);
32260 if (PyErr_Occurred()) SWIG_fail;
32261 }
32262 {
32263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32264 }
32265 {
32266 if (temp2)
32267 delete arg2;
32268 }
32269 return resultobj;
32270 fail:
32271 {
32272 if (temp2)
32273 delete arg2;
32274 }
32275 return NULL;
32276 }
32277
32278
32279 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32280 PyObject *obj;
32281 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32282 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
32283 return SWIG_Py_Void();
32284 }
32285
32286 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32287 return SWIG_Python_InitShadowInstance(args);
32288 }
32289
32290 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32291 PyObject *resultobj = 0;
32292 int arg1 ;
32293 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
32294 wxAcceleratorTable *result = 0 ;
32295 PyObject * obj0 = 0 ;
32296 char * kwnames[] = {
32297 (char *) "n", NULL
32298 };
32299
32300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
32301 {
32302 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
32303 if (arg2) arg1 = PyList_Size(obj0);
32304 else arg1 = 0;
32305 }
32306 {
32307 PyThreadState* __tstate = wxPyBeginAllowThreads();
32308 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
32309 wxPyEndAllowThreads(__tstate);
32310 if (PyErr_Occurred()) SWIG_fail;
32311 }
32312 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
32313 return resultobj;
32314 fail:
32315 return NULL;
32316 }
32317
32318
32319 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32320 PyObject *resultobj = 0;
32321 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32322 void *argp1 = 0 ;
32323 int res1 = 0 ;
32324 PyObject *swig_obj[1] ;
32325
32326 if (!args) SWIG_fail;
32327 swig_obj[0] = args;
32328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
32329 if (!SWIG_IsOK(res1)) {
32330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
32331 }
32332 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32333 {
32334 PyThreadState* __tstate = wxPyBeginAllowThreads();
32335 delete arg1;
32336
32337 wxPyEndAllowThreads(__tstate);
32338 if (PyErr_Occurred()) SWIG_fail;
32339 }
32340 resultobj = SWIG_Py_Void();
32341 return resultobj;
32342 fail:
32343 return NULL;
32344 }
32345
32346
32347 SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32348 PyObject *resultobj = 0;
32349 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32350 bool result;
32351 void *argp1 = 0 ;
32352 int res1 = 0 ;
32353 PyObject *swig_obj[1] ;
32354
32355 if (!args) SWIG_fail;
32356 swig_obj[0] = args;
32357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
32358 if (!SWIG_IsOK(res1)) {
32359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
32360 }
32361 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32362 {
32363 PyThreadState* __tstate = wxPyBeginAllowThreads();
32364 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
32365 wxPyEndAllowThreads(__tstate);
32366 if (PyErr_Occurred()) SWIG_fail;
32367 }
32368 {
32369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32370 }
32371 return resultobj;
32372 fail:
32373 return NULL;
32374 }
32375
32376
32377 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32378 PyObject *obj;
32379 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32380 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
32381 return SWIG_Py_Void();
32382 }
32383
32384 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32385 return SWIG_Python_InitShadowInstance(args);
32386 }
32387
32388 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
32389 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
32390 return 1;
32391 }
32392
32393
32394 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
32395 PyObject *pyobj = 0;
32396
32397 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
32398 return pyobj;
32399 }
32400
32401
32402 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32403 PyObject *resultobj = 0;
32404 wxString *arg1 = 0 ;
32405 wxAcceleratorEntry *result = 0 ;
32406 bool temp1 = false ;
32407 PyObject * obj0 = 0 ;
32408 char * kwnames[] = {
32409 (char *) "label", NULL
32410 };
32411
32412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
32413 {
32414 arg1 = wxString_in_helper(obj0);
32415 if (arg1 == NULL) SWIG_fail;
32416 temp1 = true;
32417 }
32418 {
32419 PyThreadState* __tstate = wxPyBeginAllowThreads();
32420 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
32421 wxPyEndAllowThreads(__tstate);
32422 if (PyErr_Occurred()) SWIG_fail;
32423 }
32424 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32425 {
32426 if (temp1)
32427 delete arg1;
32428 }
32429 return resultobj;
32430 fail:
32431 {
32432 if (temp1)
32433 delete arg1;
32434 }
32435 return NULL;
32436 }
32437
32438
32439 SWIGINTERN int PanelNameStr_set(PyObject *) {
32440 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
32441 return 1;
32442 }
32443
32444
32445 SWIGINTERN PyObject *PanelNameStr_get(void) {
32446 PyObject *pyobj = 0;
32447
32448 {
32449 #if wxUSE_UNICODE
32450 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32451 #else
32452 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32453 #endif
32454 }
32455 return pyobj;
32456 }
32457
32458
32459 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32460 PyObject *resultobj = 0;
32461 wxVisualAttributes *result = 0 ;
32462
32463 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
32464 {
32465 PyThreadState* __tstate = wxPyBeginAllowThreads();
32466 result = (wxVisualAttributes *)new_wxVisualAttributes();
32467 wxPyEndAllowThreads(__tstate);
32468 if (PyErr_Occurred()) SWIG_fail;
32469 }
32470 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
32471 return resultobj;
32472 fail:
32473 return NULL;
32474 }
32475
32476
32477 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32478 PyObject *resultobj = 0;
32479 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32480 void *argp1 = 0 ;
32481 int res1 = 0 ;
32482 PyObject *swig_obj[1] ;
32483
32484 if (!args) SWIG_fail;
32485 swig_obj[0] = args;
32486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
32487 if (!SWIG_IsOK(res1)) {
32488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32489 }
32490 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32491 {
32492 PyThreadState* __tstate = wxPyBeginAllowThreads();
32493 delete_wxVisualAttributes(arg1);
32494
32495 wxPyEndAllowThreads(__tstate);
32496 if (PyErr_Occurred()) SWIG_fail;
32497 }
32498 resultobj = SWIG_Py_Void();
32499 return resultobj;
32500 fail:
32501 return NULL;
32502 }
32503
32504
32505 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32506 PyObject *resultobj = 0;
32507 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32508 wxFont *arg2 = (wxFont *) 0 ;
32509 void *argp1 = 0 ;
32510 int res1 = 0 ;
32511 void *argp2 = 0 ;
32512 int res2 = 0 ;
32513 PyObject *swig_obj[2] ;
32514
32515 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
32516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32517 if (!SWIG_IsOK(res1)) {
32518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32519 }
32520 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32521 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
32522 if (!SWIG_IsOK(res2)) {
32523 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
32524 }
32525 arg2 = reinterpret_cast< wxFont * >(argp2);
32526 if (arg1) (arg1)->font = *arg2;
32527
32528 resultobj = SWIG_Py_Void();
32529 return resultobj;
32530 fail:
32531 return NULL;
32532 }
32533
32534
32535 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32536 PyObject *resultobj = 0;
32537 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32538 wxFont *result = 0 ;
32539 void *argp1 = 0 ;
32540 int res1 = 0 ;
32541 PyObject *swig_obj[1] ;
32542
32543 if (!args) SWIG_fail;
32544 swig_obj[0] = args;
32545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32546 if (!SWIG_IsOK(res1)) {
32547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32548 }
32549 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32550 result = (wxFont *)& ((arg1)->font);
32551 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
32552 return resultobj;
32553 fail:
32554 return NULL;
32555 }
32556
32557
32558 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32559 PyObject *resultobj = 0;
32560 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32561 wxColour *arg2 = (wxColour *) 0 ;
32562 void *argp1 = 0 ;
32563 int res1 = 0 ;
32564 void *argp2 = 0 ;
32565 int res2 = 0 ;
32566 PyObject *swig_obj[2] ;
32567
32568 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
32569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32570 if (!SWIG_IsOK(res1)) {
32571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32572 }
32573 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32574 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32575 if (!SWIG_IsOK(res2)) {
32576 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32577 }
32578 arg2 = reinterpret_cast< wxColour * >(argp2);
32579 if (arg1) (arg1)->colFg = *arg2;
32580
32581 resultobj = SWIG_Py_Void();
32582 return resultobj;
32583 fail:
32584 return NULL;
32585 }
32586
32587
32588 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32589 PyObject *resultobj = 0;
32590 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32591 wxColour *result = 0 ;
32592 void *argp1 = 0 ;
32593 int res1 = 0 ;
32594 PyObject *swig_obj[1] ;
32595
32596 if (!args) SWIG_fail;
32597 swig_obj[0] = args;
32598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32599 if (!SWIG_IsOK(res1)) {
32600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32601 }
32602 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32603 result = (wxColour *)& ((arg1)->colFg);
32604 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32605 return resultobj;
32606 fail:
32607 return NULL;
32608 }
32609
32610
32611 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32612 PyObject *resultobj = 0;
32613 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32614 wxColour *arg2 = (wxColour *) 0 ;
32615 void *argp1 = 0 ;
32616 int res1 = 0 ;
32617 void *argp2 = 0 ;
32618 int res2 = 0 ;
32619 PyObject *swig_obj[2] ;
32620
32621 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
32622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32623 if (!SWIG_IsOK(res1)) {
32624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32625 }
32626 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32627 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32628 if (!SWIG_IsOK(res2)) {
32629 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32630 }
32631 arg2 = reinterpret_cast< wxColour * >(argp2);
32632 if (arg1) (arg1)->colBg = *arg2;
32633
32634 resultobj = SWIG_Py_Void();
32635 return resultobj;
32636 fail:
32637 return NULL;
32638 }
32639
32640
32641 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32642 PyObject *resultobj = 0;
32643 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32644 wxColour *result = 0 ;
32645 void *argp1 = 0 ;
32646 int res1 = 0 ;
32647 PyObject *swig_obj[1] ;
32648
32649 if (!args) SWIG_fail;
32650 swig_obj[0] = args;
32651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32652 if (!SWIG_IsOK(res1)) {
32653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32654 }
32655 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32656 result = (wxColour *)& ((arg1)->colBg);
32657 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32658 return resultobj;
32659 fail:
32660 return NULL;
32661 }
32662
32663
32664 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32665 PyObject *obj;
32666 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32667 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
32668 return SWIG_Py_Void();
32669 }
32670
32671 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32672 return SWIG_Python_InitShadowInstance(args);
32673 }
32674
32675 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32676 PyObject *resultobj = 0;
32677 wxWindow *arg1 = (wxWindow *) 0 ;
32678 int arg2 = (int) (int)-1 ;
32679 wxPoint const &arg3_defvalue = wxDefaultPosition ;
32680 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
32681 wxSize const &arg4_defvalue = wxDefaultSize ;
32682 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32683 long arg5 = (long) 0 ;
32684 wxString const &arg6_defvalue = wxPyPanelNameStr ;
32685 wxString *arg6 = (wxString *) &arg6_defvalue ;
32686 wxWindow *result = 0 ;
32687 void *argp1 = 0 ;
32688 int res1 = 0 ;
32689 int val2 ;
32690 int ecode2 = 0 ;
32691 wxPoint temp3 ;
32692 wxSize temp4 ;
32693 long val5 ;
32694 int ecode5 = 0 ;
32695 bool temp6 = false ;
32696 PyObject * obj0 = 0 ;
32697 PyObject * obj1 = 0 ;
32698 PyObject * obj2 = 0 ;
32699 PyObject * obj3 = 0 ;
32700 PyObject * obj4 = 0 ;
32701 PyObject * obj5 = 0 ;
32702 char * kwnames[] = {
32703 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32704 };
32705
32706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
32707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32708 if (!SWIG_IsOK(res1)) {
32709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
32710 }
32711 arg1 = reinterpret_cast< wxWindow * >(argp1);
32712 if (obj1) {
32713 ecode2 = SWIG_AsVal_int(obj1, &val2);
32714 if (!SWIG_IsOK(ecode2)) {
32715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
32716 }
32717 arg2 = static_cast< int >(val2);
32718 }
32719 if (obj2) {
32720 {
32721 arg3 = &temp3;
32722 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
32723 }
32724 }
32725 if (obj3) {
32726 {
32727 arg4 = &temp4;
32728 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32729 }
32730 }
32731 if (obj4) {
32732 ecode5 = SWIG_AsVal_long(obj4, &val5);
32733 if (!SWIG_IsOK(ecode5)) {
32734 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
32735 }
32736 arg5 = static_cast< long >(val5);
32737 }
32738 if (obj5) {
32739 {
32740 arg6 = wxString_in_helper(obj5);
32741 if (arg6 == NULL) SWIG_fail;
32742 temp6 = true;
32743 }
32744 }
32745 {
32746 if (!wxPyCheckForApp()) SWIG_fail;
32747 PyThreadState* __tstate = wxPyBeginAllowThreads();
32748 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
32749 wxPyEndAllowThreads(__tstate);
32750 if (PyErr_Occurred()) SWIG_fail;
32751 }
32752 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
32753 {
32754 if (temp6)
32755 delete arg6;
32756 }
32757 return resultobj;
32758 fail:
32759 {
32760 if (temp6)
32761 delete arg6;
32762 }
32763 return NULL;
32764 }
32765
32766
32767 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32768 PyObject *resultobj = 0;
32769 wxWindow *result = 0 ;
32770
32771 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
32772 {
32773 if (!wxPyCheckForApp()) SWIG_fail;
32774 PyThreadState* __tstate = wxPyBeginAllowThreads();
32775 result = (wxWindow *)new wxWindow();
32776 wxPyEndAllowThreads(__tstate);
32777 if (PyErr_Occurred()) SWIG_fail;
32778 }
32779 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
32780 return resultobj;
32781 fail:
32782 return NULL;
32783 }
32784
32785
32786 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32787 PyObject *resultobj = 0;
32788 wxWindow *arg1 = (wxWindow *) 0 ;
32789 wxWindow *arg2 = (wxWindow *) 0 ;
32790 int arg3 = (int) (int)-1 ;
32791 wxPoint const &arg4_defvalue = wxDefaultPosition ;
32792 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
32793 wxSize const &arg5_defvalue = wxDefaultSize ;
32794 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
32795 long arg6 = (long) 0 ;
32796 wxString const &arg7_defvalue = wxPyPanelNameStr ;
32797 wxString *arg7 = (wxString *) &arg7_defvalue ;
32798 bool result;
32799 void *argp1 = 0 ;
32800 int res1 = 0 ;
32801 void *argp2 = 0 ;
32802 int res2 = 0 ;
32803 int val3 ;
32804 int ecode3 = 0 ;
32805 wxPoint temp4 ;
32806 wxSize temp5 ;
32807 long val6 ;
32808 int ecode6 = 0 ;
32809 bool temp7 = false ;
32810 PyObject * obj0 = 0 ;
32811 PyObject * obj1 = 0 ;
32812 PyObject * obj2 = 0 ;
32813 PyObject * obj3 = 0 ;
32814 PyObject * obj4 = 0 ;
32815 PyObject * obj5 = 0 ;
32816 PyObject * obj6 = 0 ;
32817 char * kwnames[] = {
32818 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32819 };
32820
32821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32823 if (!SWIG_IsOK(res1)) {
32824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
32825 }
32826 arg1 = reinterpret_cast< wxWindow * >(argp1);
32827 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32828 if (!SWIG_IsOK(res2)) {
32829 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
32830 }
32831 arg2 = reinterpret_cast< wxWindow * >(argp2);
32832 if (obj2) {
32833 ecode3 = SWIG_AsVal_int(obj2, &val3);
32834 if (!SWIG_IsOK(ecode3)) {
32835 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
32836 }
32837 arg3 = static_cast< int >(val3);
32838 }
32839 if (obj3) {
32840 {
32841 arg4 = &temp4;
32842 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
32843 }
32844 }
32845 if (obj4) {
32846 {
32847 arg5 = &temp5;
32848 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
32849 }
32850 }
32851 if (obj5) {
32852 ecode6 = SWIG_AsVal_long(obj5, &val6);
32853 if (!SWIG_IsOK(ecode6)) {
32854 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
32855 }
32856 arg6 = static_cast< long >(val6);
32857 }
32858 if (obj6) {
32859 {
32860 arg7 = wxString_in_helper(obj6);
32861 if (arg7 == NULL) SWIG_fail;
32862 temp7 = true;
32863 }
32864 }
32865 {
32866 PyThreadState* __tstate = wxPyBeginAllowThreads();
32867 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
32868 wxPyEndAllowThreads(__tstate);
32869 if (PyErr_Occurred()) SWIG_fail;
32870 }
32871 {
32872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32873 }
32874 {
32875 if (temp7)
32876 delete arg7;
32877 }
32878 return resultobj;
32879 fail:
32880 {
32881 if (temp7)
32882 delete arg7;
32883 }
32884 return NULL;
32885 }
32886
32887
32888 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32889 PyObject *resultobj = 0;
32890 wxWindow *arg1 = (wxWindow *) 0 ;
32891 bool arg2 = (bool) false ;
32892 bool result;
32893 void *argp1 = 0 ;
32894 int res1 = 0 ;
32895 bool val2 ;
32896 int ecode2 = 0 ;
32897 PyObject * obj0 = 0 ;
32898 PyObject * obj1 = 0 ;
32899 char * kwnames[] = {
32900 (char *) "self",(char *) "force", NULL
32901 };
32902
32903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
32904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32905 if (!SWIG_IsOK(res1)) {
32906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
32907 }
32908 arg1 = reinterpret_cast< wxWindow * >(argp1);
32909 if (obj1) {
32910 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32911 if (!SWIG_IsOK(ecode2)) {
32912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
32913 }
32914 arg2 = static_cast< bool >(val2);
32915 }
32916 {
32917 PyThreadState* __tstate = wxPyBeginAllowThreads();
32918 result = (bool)(arg1)->Close(arg2);
32919 wxPyEndAllowThreads(__tstate);
32920 if (PyErr_Occurred()) SWIG_fail;
32921 }
32922 {
32923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32924 }
32925 return resultobj;
32926 fail:
32927 return NULL;
32928 }
32929
32930
32931 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32932 PyObject *resultobj = 0;
32933 wxWindow *arg1 = (wxWindow *) 0 ;
32934 bool result;
32935 void *argp1 = 0 ;
32936 int res1 = 0 ;
32937 PyObject *swig_obj[1] ;
32938
32939 if (!args) SWIG_fail;
32940 swig_obj[0] = args;
32941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32942 if (!SWIG_IsOK(res1)) {
32943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
32944 }
32945 arg1 = reinterpret_cast< wxWindow * >(argp1);
32946 {
32947 PyThreadState* __tstate = wxPyBeginAllowThreads();
32948 result = (bool)(arg1)->Destroy();
32949 wxPyEndAllowThreads(__tstate);
32950 if (PyErr_Occurred()) SWIG_fail;
32951 }
32952 {
32953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32954 }
32955 return resultobj;
32956 fail:
32957 return NULL;
32958 }
32959
32960
32961 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32962 PyObject *resultobj = 0;
32963 wxWindow *arg1 = (wxWindow *) 0 ;
32964 bool result;
32965 void *argp1 = 0 ;
32966 int res1 = 0 ;
32967 PyObject *swig_obj[1] ;
32968
32969 if (!args) SWIG_fail;
32970 swig_obj[0] = args;
32971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32972 if (!SWIG_IsOK(res1)) {
32973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
32974 }
32975 arg1 = reinterpret_cast< wxWindow * >(argp1);
32976 {
32977 PyThreadState* __tstate = wxPyBeginAllowThreads();
32978 result = (bool)(arg1)->DestroyChildren();
32979 wxPyEndAllowThreads(__tstate);
32980 if (PyErr_Occurred()) SWIG_fail;
32981 }
32982 {
32983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32984 }
32985 return resultobj;
32986 fail:
32987 return NULL;
32988 }
32989
32990
32991 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32992 PyObject *resultobj = 0;
32993 wxWindow *arg1 = (wxWindow *) 0 ;
32994 bool result;
32995 void *argp1 = 0 ;
32996 int res1 = 0 ;
32997 PyObject *swig_obj[1] ;
32998
32999 if (!args) SWIG_fail;
33000 swig_obj[0] = args;
33001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33002 if (!SWIG_IsOK(res1)) {
33003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
33004 }
33005 arg1 = reinterpret_cast< wxWindow * >(argp1);
33006 {
33007 PyThreadState* __tstate = wxPyBeginAllowThreads();
33008 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
33009 wxPyEndAllowThreads(__tstate);
33010 if (PyErr_Occurred()) SWIG_fail;
33011 }
33012 {
33013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33014 }
33015 return resultobj;
33016 fail:
33017 return NULL;
33018 }
33019
33020
33021 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33022 PyObject *resultobj = 0;
33023 wxWindow *arg1 = (wxWindow *) 0 ;
33024 wxString *arg2 = 0 ;
33025 void *argp1 = 0 ;
33026 int res1 = 0 ;
33027 bool temp2 = false ;
33028 PyObject * obj0 = 0 ;
33029 PyObject * obj1 = 0 ;
33030 char * kwnames[] = {
33031 (char *) "self",(char *) "label", NULL
33032 };
33033
33034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
33035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33036 if (!SWIG_IsOK(res1)) {
33037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
33038 }
33039 arg1 = reinterpret_cast< wxWindow * >(argp1);
33040 {
33041 arg2 = wxString_in_helper(obj1);
33042 if (arg2 == NULL) SWIG_fail;
33043 temp2 = true;
33044 }
33045 {
33046 PyThreadState* __tstate = wxPyBeginAllowThreads();
33047 (arg1)->SetLabel((wxString const &)*arg2);
33048 wxPyEndAllowThreads(__tstate);
33049 if (PyErr_Occurred()) SWIG_fail;
33050 }
33051 resultobj = SWIG_Py_Void();
33052 {
33053 if (temp2)
33054 delete arg2;
33055 }
33056 return resultobj;
33057 fail:
33058 {
33059 if (temp2)
33060 delete arg2;
33061 }
33062 return NULL;
33063 }
33064
33065
33066 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33067 PyObject *resultobj = 0;
33068 wxWindow *arg1 = (wxWindow *) 0 ;
33069 wxString result;
33070 void *argp1 = 0 ;
33071 int res1 = 0 ;
33072 PyObject *swig_obj[1] ;
33073
33074 if (!args) SWIG_fail;
33075 swig_obj[0] = args;
33076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33077 if (!SWIG_IsOK(res1)) {
33078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33079 }
33080 arg1 = reinterpret_cast< wxWindow * >(argp1);
33081 {
33082 PyThreadState* __tstate = wxPyBeginAllowThreads();
33083 result = ((wxWindow const *)arg1)->GetLabel();
33084 wxPyEndAllowThreads(__tstate);
33085 if (PyErr_Occurred()) SWIG_fail;
33086 }
33087 {
33088 #if wxUSE_UNICODE
33089 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33090 #else
33091 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33092 #endif
33093 }
33094 return resultobj;
33095 fail:
33096 return NULL;
33097 }
33098
33099
33100 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33101 PyObject *resultobj = 0;
33102 wxWindow *arg1 = (wxWindow *) 0 ;
33103 wxString *arg2 = 0 ;
33104 void *argp1 = 0 ;
33105 int res1 = 0 ;
33106 bool temp2 = false ;
33107 PyObject * obj0 = 0 ;
33108 PyObject * obj1 = 0 ;
33109 char * kwnames[] = {
33110 (char *) "self",(char *) "name", NULL
33111 };
33112
33113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
33114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33115 if (!SWIG_IsOK(res1)) {
33116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
33117 }
33118 arg1 = reinterpret_cast< wxWindow * >(argp1);
33119 {
33120 arg2 = wxString_in_helper(obj1);
33121 if (arg2 == NULL) SWIG_fail;
33122 temp2 = true;
33123 }
33124 {
33125 PyThreadState* __tstate = wxPyBeginAllowThreads();
33126 (arg1)->SetName((wxString const &)*arg2);
33127 wxPyEndAllowThreads(__tstate);
33128 if (PyErr_Occurred()) SWIG_fail;
33129 }
33130 resultobj = SWIG_Py_Void();
33131 {
33132 if (temp2)
33133 delete arg2;
33134 }
33135 return resultobj;
33136 fail:
33137 {
33138 if (temp2)
33139 delete arg2;
33140 }
33141 return NULL;
33142 }
33143
33144
33145 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33146 PyObject *resultobj = 0;
33147 wxWindow *arg1 = (wxWindow *) 0 ;
33148 wxString result;
33149 void *argp1 = 0 ;
33150 int res1 = 0 ;
33151 PyObject *swig_obj[1] ;
33152
33153 if (!args) SWIG_fail;
33154 swig_obj[0] = args;
33155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33156 if (!SWIG_IsOK(res1)) {
33157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
33158 }
33159 arg1 = reinterpret_cast< wxWindow * >(argp1);
33160 {
33161 PyThreadState* __tstate = wxPyBeginAllowThreads();
33162 result = ((wxWindow const *)arg1)->GetName();
33163 wxPyEndAllowThreads(__tstate);
33164 if (PyErr_Occurred()) SWIG_fail;
33165 }
33166 {
33167 #if wxUSE_UNICODE
33168 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33169 #else
33170 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33171 #endif
33172 }
33173 return resultobj;
33174 fail:
33175 return NULL;
33176 }
33177
33178
33179 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33180 PyObject *resultobj = 0;
33181 wxWindow *arg1 = (wxWindow *) 0 ;
33182 wxWindowVariant arg2 ;
33183 void *argp1 = 0 ;
33184 int res1 = 0 ;
33185 int val2 ;
33186 int ecode2 = 0 ;
33187 PyObject * obj0 = 0 ;
33188 PyObject * obj1 = 0 ;
33189 char * kwnames[] = {
33190 (char *) "self",(char *) "variant", NULL
33191 };
33192
33193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
33194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33195 if (!SWIG_IsOK(res1)) {
33196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
33197 }
33198 arg1 = reinterpret_cast< wxWindow * >(argp1);
33199 ecode2 = SWIG_AsVal_int(obj1, &val2);
33200 if (!SWIG_IsOK(ecode2)) {
33201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
33202 }
33203 arg2 = static_cast< wxWindowVariant >(val2);
33204 {
33205 PyThreadState* __tstate = wxPyBeginAllowThreads();
33206 (arg1)->SetWindowVariant(arg2);
33207 wxPyEndAllowThreads(__tstate);
33208 if (PyErr_Occurred()) SWIG_fail;
33209 }
33210 resultobj = SWIG_Py_Void();
33211 return resultobj;
33212 fail:
33213 return NULL;
33214 }
33215
33216
33217 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33218 PyObject *resultobj = 0;
33219 wxWindow *arg1 = (wxWindow *) 0 ;
33220 wxWindowVariant result;
33221 void *argp1 = 0 ;
33222 int res1 = 0 ;
33223 PyObject *swig_obj[1] ;
33224
33225 if (!args) SWIG_fail;
33226 swig_obj[0] = args;
33227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33228 if (!SWIG_IsOK(res1)) {
33229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
33230 }
33231 arg1 = reinterpret_cast< wxWindow * >(argp1);
33232 {
33233 PyThreadState* __tstate = wxPyBeginAllowThreads();
33234 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
33235 wxPyEndAllowThreads(__tstate);
33236 if (PyErr_Occurred()) SWIG_fail;
33237 }
33238 resultobj = SWIG_From_int(static_cast< int >(result));
33239 return resultobj;
33240 fail:
33241 return NULL;
33242 }
33243
33244
33245 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33246 PyObject *resultobj = 0;
33247 wxWindow *arg1 = (wxWindow *) 0 ;
33248 int arg2 ;
33249 void *argp1 = 0 ;
33250 int res1 = 0 ;
33251 int val2 ;
33252 int ecode2 = 0 ;
33253 PyObject * obj0 = 0 ;
33254 PyObject * obj1 = 0 ;
33255 char * kwnames[] = {
33256 (char *) "self",(char *) "winid", NULL
33257 };
33258
33259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
33260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33261 if (!SWIG_IsOK(res1)) {
33262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
33263 }
33264 arg1 = reinterpret_cast< wxWindow * >(argp1);
33265 ecode2 = SWIG_AsVal_int(obj1, &val2);
33266 if (!SWIG_IsOK(ecode2)) {
33267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
33268 }
33269 arg2 = static_cast< int >(val2);
33270 {
33271 PyThreadState* __tstate = wxPyBeginAllowThreads();
33272 (arg1)->SetId(arg2);
33273 wxPyEndAllowThreads(__tstate);
33274 if (PyErr_Occurred()) SWIG_fail;
33275 }
33276 resultobj = SWIG_Py_Void();
33277 return resultobj;
33278 fail:
33279 return NULL;
33280 }
33281
33282
33283 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33284 PyObject *resultobj = 0;
33285 wxWindow *arg1 = (wxWindow *) 0 ;
33286 int result;
33287 void *argp1 = 0 ;
33288 int res1 = 0 ;
33289 PyObject *swig_obj[1] ;
33290
33291 if (!args) SWIG_fail;
33292 swig_obj[0] = args;
33293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33294 if (!SWIG_IsOK(res1)) {
33295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
33296 }
33297 arg1 = reinterpret_cast< wxWindow * >(argp1);
33298 {
33299 PyThreadState* __tstate = wxPyBeginAllowThreads();
33300 result = (int)((wxWindow const *)arg1)->GetId();
33301 wxPyEndAllowThreads(__tstate);
33302 if (PyErr_Occurred()) SWIG_fail;
33303 }
33304 resultobj = SWIG_From_int(static_cast< int >(result));
33305 return resultobj;
33306 fail:
33307 return NULL;
33308 }
33309
33310
33311 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33312 PyObject *resultobj = 0;
33313 int result;
33314
33315 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
33316 {
33317 PyThreadState* __tstate = wxPyBeginAllowThreads();
33318 result = (int)wxWindow::NewControlId();
33319 wxPyEndAllowThreads(__tstate);
33320 if (PyErr_Occurred()) SWIG_fail;
33321 }
33322 resultobj = SWIG_From_int(static_cast< int >(result));
33323 return resultobj;
33324 fail:
33325 return NULL;
33326 }
33327
33328
33329 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33330 PyObject *resultobj = 0;
33331 int arg1 ;
33332 int result;
33333 int val1 ;
33334 int ecode1 = 0 ;
33335 PyObject * obj0 = 0 ;
33336 char * kwnames[] = {
33337 (char *) "winid", NULL
33338 };
33339
33340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
33341 ecode1 = SWIG_AsVal_int(obj0, &val1);
33342 if (!SWIG_IsOK(ecode1)) {
33343 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
33344 }
33345 arg1 = static_cast< int >(val1);
33346 {
33347 PyThreadState* __tstate = wxPyBeginAllowThreads();
33348 result = (int)wxWindow::NextControlId(arg1);
33349 wxPyEndAllowThreads(__tstate);
33350 if (PyErr_Occurred()) SWIG_fail;
33351 }
33352 resultobj = SWIG_From_int(static_cast< int >(result));
33353 return resultobj;
33354 fail:
33355 return NULL;
33356 }
33357
33358
33359 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33360 PyObject *resultobj = 0;
33361 int arg1 ;
33362 int result;
33363 int val1 ;
33364 int ecode1 = 0 ;
33365 PyObject * obj0 = 0 ;
33366 char * kwnames[] = {
33367 (char *) "winid", NULL
33368 };
33369
33370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
33371 ecode1 = SWIG_AsVal_int(obj0, &val1);
33372 if (!SWIG_IsOK(ecode1)) {
33373 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
33374 }
33375 arg1 = static_cast< int >(val1);
33376 {
33377 PyThreadState* __tstate = wxPyBeginAllowThreads();
33378 result = (int)wxWindow::PrevControlId(arg1);
33379 wxPyEndAllowThreads(__tstate);
33380 if (PyErr_Occurred()) SWIG_fail;
33381 }
33382 resultobj = SWIG_From_int(static_cast< int >(result));
33383 return resultobj;
33384 fail:
33385 return NULL;
33386 }
33387
33388
33389 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33390 PyObject *resultobj = 0;
33391 wxWindow *arg1 = (wxWindow *) 0 ;
33392 wxLayoutDirection result;
33393 void *argp1 = 0 ;
33394 int res1 = 0 ;
33395 PyObject *swig_obj[1] ;
33396
33397 if (!args) SWIG_fail;
33398 swig_obj[0] = args;
33399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33400 if (!SWIG_IsOK(res1)) {
33401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33402 }
33403 arg1 = reinterpret_cast< wxWindow * >(argp1);
33404 {
33405 PyThreadState* __tstate = wxPyBeginAllowThreads();
33406 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
33407 wxPyEndAllowThreads(__tstate);
33408 if (PyErr_Occurred()) SWIG_fail;
33409 }
33410 resultobj = SWIG_From_int(static_cast< int >(result));
33411 return resultobj;
33412 fail:
33413 return NULL;
33414 }
33415
33416
33417 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33418 PyObject *resultobj = 0;
33419 wxWindow *arg1 = (wxWindow *) 0 ;
33420 wxLayoutDirection arg2 ;
33421 void *argp1 = 0 ;
33422 int res1 = 0 ;
33423 int val2 ;
33424 int ecode2 = 0 ;
33425 PyObject * obj0 = 0 ;
33426 PyObject * obj1 = 0 ;
33427 char * kwnames[] = {
33428 (char *) "self",(char *) "dir", NULL
33429 };
33430
33431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
33432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33433 if (!SWIG_IsOK(res1)) {
33434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
33435 }
33436 arg1 = reinterpret_cast< wxWindow * >(argp1);
33437 ecode2 = SWIG_AsVal_int(obj1, &val2);
33438 if (!SWIG_IsOK(ecode2)) {
33439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
33440 }
33441 arg2 = static_cast< wxLayoutDirection >(val2);
33442 {
33443 PyThreadState* __tstate = wxPyBeginAllowThreads();
33444 (arg1)->SetLayoutDirection(arg2);
33445 wxPyEndAllowThreads(__tstate);
33446 if (PyErr_Occurred()) SWIG_fail;
33447 }
33448 resultobj = SWIG_Py_Void();
33449 return resultobj;
33450 fail:
33451 return NULL;
33452 }
33453
33454
33455 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33456 PyObject *resultobj = 0;
33457 wxWindow *arg1 = (wxWindow *) 0 ;
33458 int arg2 ;
33459 int arg3 ;
33460 int arg4 ;
33461 int result;
33462 void *argp1 = 0 ;
33463 int res1 = 0 ;
33464 int val2 ;
33465 int ecode2 = 0 ;
33466 int val3 ;
33467 int ecode3 = 0 ;
33468 int val4 ;
33469 int ecode4 = 0 ;
33470 PyObject * obj0 = 0 ;
33471 PyObject * obj1 = 0 ;
33472 PyObject * obj2 = 0 ;
33473 PyObject * obj3 = 0 ;
33474 char * kwnames[] = {
33475 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
33476 };
33477
33478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33480 if (!SWIG_IsOK(res1)) {
33481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33482 }
33483 arg1 = reinterpret_cast< wxWindow * >(argp1);
33484 ecode2 = SWIG_AsVal_int(obj1, &val2);
33485 if (!SWIG_IsOK(ecode2)) {
33486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
33487 }
33488 arg2 = static_cast< int >(val2);
33489 ecode3 = SWIG_AsVal_int(obj2, &val3);
33490 if (!SWIG_IsOK(ecode3)) {
33491 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
33492 }
33493 arg3 = static_cast< int >(val3);
33494 ecode4 = SWIG_AsVal_int(obj3, &val4);
33495 if (!SWIG_IsOK(ecode4)) {
33496 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
33497 }
33498 arg4 = static_cast< int >(val4);
33499 {
33500 PyThreadState* __tstate = wxPyBeginAllowThreads();
33501 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
33502 wxPyEndAllowThreads(__tstate);
33503 if (PyErr_Occurred()) SWIG_fail;
33504 }
33505 resultobj = SWIG_From_int(static_cast< int >(result));
33506 return resultobj;
33507 fail:
33508 return NULL;
33509 }
33510
33511
33512 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33513 PyObject *resultobj = 0;
33514 wxWindow *arg1 = (wxWindow *) 0 ;
33515 wxSize *arg2 = 0 ;
33516 void *argp1 = 0 ;
33517 int res1 = 0 ;
33518 wxSize temp2 ;
33519 PyObject * obj0 = 0 ;
33520 PyObject * obj1 = 0 ;
33521 char * kwnames[] = {
33522 (char *) "self",(char *) "size", NULL
33523 };
33524
33525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
33526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33527 if (!SWIG_IsOK(res1)) {
33528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33529 }
33530 arg1 = reinterpret_cast< wxWindow * >(argp1);
33531 {
33532 arg2 = &temp2;
33533 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33534 }
33535 {
33536 PyThreadState* __tstate = wxPyBeginAllowThreads();
33537 (arg1)->SetSize((wxSize const &)*arg2);
33538 wxPyEndAllowThreads(__tstate);
33539 if (PyErr_Occurred()) SWIG_fail;
33540 }
33541 resultobj = SWIG_Py_Void();
33542 return resultobj;
33543 fail:
33544 return NULL;
33545 }
33546
33547
33548 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33549 PyObject *resultobj = 0;
33550 wxWindow *arg1 = (wxWindow *) 0 ;
33551 int arg2 ;
33552 int arg3 ;
33553 int arg4 ;
33554 int arg5 ;
33555 int arg6 = (int) wxSIZE_AUTO ;
33556 void *argp1 = 0 ;
33557 int res1 = 0 ;
33558 int val2 ;
33559 int ecode2 = 0 ;
33560 int val3 ;
33561 int ecode3 = 0 ;
33562 int val4 ;
33563 int ecode4 = 0 ;
33564 int val5 ;
33565 int ecode5 = 0 ;
33566 int val6 ;
33567 int ecode6 = 0 ;
33568 PyObject * obj0 = 0 ;
33569 PyObject * obj1 = 0 ;
33570 PyObject * obj2 = 0 ;
33571 PyObject * obj3 = 0 ;
33572 PyObject * obj4 = 0 ;
33573 PyObject * obj5 = 0 ;
33574 char * kwnames[] = {
33575 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
33576 };
33577
33578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
33579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33580 if (!SWIG_IsOK(res1)) {
33581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
33582 }
33583 arg1 = reinterpret_cast< wxWindow * >(argp1);
33584 ecode2 = SWIG_AsVal_int(obj1, &val2);
33585 if (!SWIG_IsOK(ecode2)) {
33586 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
33587 }
33588 arg2 = static_cast< int >(val2);
33589 ecode3 = SWIG_AsVal_int(obj2, &val3);
33590 if (!SWIG_IsOK(ecode3)) {
33591 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
33592 }
33593 arg3 = static_cast< int >(val3);
33594 ecode4 = SWIG_AsVal_int(obj3, &val4);
33595 if (!SWIG_IsOK(ecode4)) {
33596 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
33597 }
33598 arg4 = static_cast< int >(val4);
33599 ecode5 = SWIG_AsVal_int(obj4, &val5);
33600 if (!SWIG_IsOK(ecode5)) {
33601 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
33602 }
33603 arg5 = static_cast< int >(val5);
33604 if (obj5) {
33605 ecode6 = SWIG_AsVal_int(obj5, &val6);
33606 if (!SWIG_IsOK(ecode6)) {
33607 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
33608 }
33609 arg6 = static_cast< int >(val6);
33610 }
33611 {
33612 PyThreadState* __tstate = wxPyBeginAllowThreads();
33613 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
33614 wxPyEndAllowThreads(__tstate);
33615 if (PyErr_Occurred()) SWIG_fail;
33616 }
33617 resultobj = SWIG_Py_Void();
33618 return resultobj;
33619 fail:
33620 return NULL;
33621 }
33622
33623
33624 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33625 PyObject *resultobj = 0;
33626 wxWindow *arg1 = (wxWindow *) 0 ;
33627 wxRect *arg2 = 0 ;
33628 int arg3 = (int) wxSIZE_AUTO ;
33629 void *argp1 = 0 ;
33630 int res1 = 0 ;
33631 wxRect temp2 ;
33632 int val3 ;
33633 int ecode3 = 0 ;
33634 PyObject * obj0 = 0 ;
33635 PyObject * obj1 = 0 ;
33636 PyObject * obj2 = 0 ;
33637 char * kwnames[] = {
33638 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
33639 };
33640
33641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33643 if (!SWIG_IsOK(res1)) {
33644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
33645 }
33646 arg1 = reinterpret_cast< wxWindow * >(argp1);
33647 {
33648 arg2 = &temp2;
33649 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
33650 }
33651 if (obj2) {
33652 ecode3 = SWIG_AsVal_int(obj2, &val3);
33653 if (!SWIG_IsOK(ecode3)) {
33654 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
33655 }
33656 arg3 = static_cast< int >(val3);
33657 }
33658 {
33659 PyThreadState* __tstate = wxPyBeginAllowThreads();
33660 (arg1)->SetSize((wxRect const &)*arg2,arg3);
33661 wxPyEndAllowThreads(__tstate);
33662 if (PyErr_Occurred()) SWIG_fail;
33663 }
33664 resultobj = SWIG_Py_Void();
33665 return resultobj;
33666 fail:
33667 return NULL;
33668 }
33669
33670
33671 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33672 PyObject *resultobj = 0;
33673 wxWindow *arg1 = (wxWindow *) 0 ;
33674 int arg2 ;
33675 int arg3 ;
33676 void *argp1 = 0 ;
33677 int res1 = 0 ;
33678 int val2 ;
33679 int ecode2 = 0 ;
33680 int val3 ;
33681 int ecode3 = 0 ;
33682 PyObject * obj0 = 0 ;
33683 PyObject * obj1 = 0 ;
33684 PyObject * obj2 = 0 ;
33685 char * kwnames[] = {
33686 (char *) "self",(char *) "width",(char *) "height", NULL
33687 };
33688
33689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33691 if (!SWIG_IsOK(res1)) {
33692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33693 }
33694 arg1 = reinterpret_cast< wxWindow * >(argp1);
33695 ecode2 = SWIG_AsVal_int(obj1, &val2);
33696 if (!SWIG_IsOK(ecode2)) {
33697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
33698 }
33699 arg2 = static_cast< int >(val2);
33700 ecode3 = SWIG_AsVal_int(obj2, &val3);
33701 if (!SWIG_IsOK(ecode3)) {
33702 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
33703 }
33704 arg3 = static_cast< int >(val3);
33705 {
33706 PyThreadState* __tstate = wxPyBeginAllowThreads();
33707 (arg1)->SetSize(arg2,arg3);
33708 wxPyEndAllowThreads(__tstate);
33709 if (PyErr_Occurred()) SWIG_fail;
33710 }
33711 resultobj = SWIG_Py_Void();
33712 return resultobj;
33713 fail:
33714 return NULL;
33715 }
33716
33717
33718 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33719 PyObject *resultobj = 0;
33720 wxWindow *arg1 = (wxWindow *) 0 ;
33721 wxPoint *arg2 = 0 ;
33722 int arg3 = (int) wxSIZE_USE_EXISTING ;
33723 void *argp1 = 0 ;
33724 int res1 = 0 ;
33725 wxPoint temp2 ;
33726 int val3 ;
33727 int ecode3 = 0 ;
33728 PyObject * obj0 = 0 ;
33729 PyObject * obj1 = 0 ;
33730 PyObject * obj2 = 0 ;
33731 char * kwnames[] = {
33732 (char *) "self",(char *) "pt",(char *) "flags", NULL
33733 };
33734
33735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33737 if (!SWIG_IsOK(res1)) {
33738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
33739 }
33740 arg1 = reinterpret_cast< wxWindow * >(argp1);
33741 {
33742 arg2 = &temp2;
33743 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33744 }
33745 if (obj2) {
33746 ecode3 = SWIG_AsVal_int(obj2, &val3);
33747 if (!SWIG_IsOK(ecode3)) {
33748 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
33749 }
33750 arg3 = static_cast< int >(val3);
33751 }
33752 {
33753 PyThreadState* __tstate = wxPyBeginAllowThreads();
33754 (arg1)->Move((wxPoint const &)*arg2,arg3);
33755 wxPyEndAllowThreads(__tstate);
33756 if (PyErr_Occurred()) SWIG_fail;
33757 }
33758 resultobj = SWIG_Py_Void();
33759 return resultobj;
33760 fail:
33761 return NULL;
33762 }
33763
33764
33765 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33766 PyObject *resultobj = 0;
33767 wxWindow *arg1 = (wxWindow *) 0 ;
33768 int arg2 ;
33769 int arg3 ;
33770 int arg4 = (int) wxSIZE_USE_EXISTING ;
33771 void *argp1 = 0 ;
33772 int res1 = 0 ;
33773 int val2 ;
33774 int ecode2 = 0 ;
33775 int val3 ;
33776 int ecode3 = 0 ;
33777 int val4 ;
33778 int ecode4 = 0 ;
33779 PyObject * obj0 = 0 ;
33780 PyObject * obj1 = 0 ;
33781 PyObject * obj2 = 0 ;
33782 PyObject * obj3 = 0 ;
33783 char * kwnames[] = {
33784 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
33785 };
33786
33787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33789 if (!SWIG_IsOK(res1)) {
33790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
33791 }
33792 arg1 = reinterpret_cast< wxWindow * >(argp1);
33793 ecode2 = SWIG_AsVal_int(obj1, &val2);
33794 if (!SWIG_IsOK(ecode2)) {
33795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
33796 }
33797 arg2 = static_cast< int >(val2);
33798 ecode3 = SWIG_AsVal_int(obj2, &val3);
33799 if (!SWIG_IsOK(ecode3)) {
33800 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
33801 }
33802 arg3 = static_cast< int >(val3);
33803 if (obj3) {
33804 ecode4 = SWIG_AsVal_int(obj3, &val4);
33805 if (!SWIG_IsOK(ecode4)) {
33806 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
33807 }
33808 arg4 = static_cast< int >(val4);
33809 }
33810 {
33811 PyThreadState* __tstate = wxPyBeginAllowThreads();
33812 (arg1)->Move(arg2,arg3,arg4);
33813 wxPyEndAllowThreads(__tstate);
33814 if (PyErr_Occurred()) SWIG_fail;
33815 }
33816 resultobj = SWIG_Py_Void();
33817 return resultobj;
33818 fail:
33819 return NULL;
33820 }
33821
33822
33823 SWIGINTERN PyObject *_wrap_Window_SetInitialSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33824 PyObject *resultobj = 0;
33825 wxWindow *arg1 = (wxWindow *) 0 ;
33826 wxSize const &arg2_defvalue = wxDefaultSize ;
33827 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
33828 void *argp1 = 0 ;
33829 int res1 = 0 ;
33830 wxSize temp2 ;
33831 PyObject * obj0 = 0 ;
33832 PyObject * obj1 = 0 ;
33833 char * kwnames[] = {
33834 (char *) "self",(char *) "size", NULL
33835 };
33836
33837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetInitialSize",kwnames,&obj0,&obj1)) SWIG_fail;
33838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33839 if (!SWIG_IsOK(res1)) {
33840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetInitialSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33841 }
33842 arg1 = reinterpret_cast< wxWindow * >(argp1);
33843 if (obj1) {
33844 {
33845 arg2 = &temp2;
33846 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33847 }
33848 }
33849 {
33850 PyThreadState* __tstate = wxPyBeginAllowThreads();
33851 (arg1)->SetInitialSize((wxSize const &)*arg2);
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_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33863 PyObject *resultobj = 0;
33864 wxWindow *arg1 = (wxWindow *) 0 ;
33865 void *argp1 = 0 ;
33866 int res1 = 0 ;
33867 PyObject *swig_obj[1] ;
33868
33869 if (!args) SWIG_fail;
33870 swig_obj[0] = args;
33871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33872 if (!SWIG_IsOK(res1)) {
33873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
33874 }
33875 arg1 = reinterpret_cast< wxWindow * >(argp1);
33876 {
33877 PyThreadState* __tstate = wxPyBeginAllowThreads();
33878 (arg1)->Raise();
33879 wxPyEndAllowThreads(__tstate);
33880 if (PyErr_Occurred()) SWIG_fail;
33881 }
33882 resultobj = SWIG_Py_Void();
33883 return resultobj;
33884 fail:
33885 return NULL;
33886 }
33887
33888
33889 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33890 PyObject *resultobj = 0;
33891 wxWindow *arg1 = (wxWindow *) 0 ;
33892 void *argp1 = 0 ;
33893 int res1 = 0 ;
33894 PyObject *swig_obj[1] ;
33895
33896 if (!args) SWIG_fail;
33897 swig_obj[0] = args;
33898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33899 if (!SWIG_IsOK(res1)) {
33900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
33901 }
33902 arg1 = reinterpret_cast< wxWindow * >(argp1);
33903 {
33904 PyThreadState* __tstate = wxPyBeginAllowThreads();
33905 (arg1)->Lower();
33906 wxPyEndAllowThreads(__tstate);
33907 if (PyErr_Occurred()) SWIG_fail;
33908 }
33909 resultobj = SWIG_Py_Void();
33910 return resultobj;
33911 fail:
33912 return NULL;
33913 }
33914
33915
33916 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33917 PyObject *resultobj = 0;
33918 wxWindow *arg1 = (wxWindow *) 0 ;
33919 wxSize *arg2 = 0 ;
33920 void *argp1 = 0 ;
33921 int res1 = 0 ;
33922 wxSize temp2 ;
33923 PyObject * obj0 = 0 ;
33924 PyObject * obj1 = 0 ;
33925 char * kwnames[] = {
33926 (char *) "self",(char *) "size", NULL
33927 };
33928
33929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
33930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33931 if (!SWIG_IsOK(res1)) {
33932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33933 }
33934 arg1 = reinterpret_cast< wxWindow * >(argp1);
33935 {
33936 arg2 = &temp2;
33937 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33938 }
33939 {
33940 PyThreadState* __tstate = wxPyBeginAllowThreads();
33941 (arg1)->SetClientSize((wxSize const &)*arg2);
33942 wxPyEndAllowThreads(__tstate);
33943 if (PyErr_Occurred()) SWIG_fail;
33944 }
33945 resultobj = SWIG_Py_Void();
33946 return resultobj;
33947 fail:
33948 return NULL;
33949 }
33950
33951
33952 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33953 PyObject *resultobj = 0;
33954 wxWindow *arg1 = (wxWindow *) 0 ;
33955 int arg2 ;
33956 int arg3 ;
33957 void *argp1 = 0 ;
33958 int res1 = 0 ;
33959 int val2 ;
33960 int ecode2 = 0 ;
33961 int val3 ;
33962 int ecode3 = 0 ;
33963 PyObject * obj0 = 0 ;
33964 PyObject * obj1 = 0 ;
33965 PyObject * obj2 = 0 ;
33966 char * kwnames[] = {
33967 (char *) "self",(char *) "width",(char *) "height", NULL
33968 };
33969
33970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33972 if (!SWIG_IsOK(res1)) {
33973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33974 }
33975 arg1 = reinterpret_cast< wxWindow * >(argp1);
33976 ecode2 = SWIG_AsVal_int(obj1, &val2);
33977 if (!SWIG_IsOK(ecode2)) {
33978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
33979 }
33980 arg2 = static_cast< int >(val2);
33981 ecode3 = SWIG_AsVal_int(obj2, &val3);
33982 if (!SWIG_IsOK(ecode3)) {
33983 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
33984 }
33985 arg3 = static_cast< int >(val3);
33986 {
33987 PyThreadState* __tstate = wxPyBeginAllowThreads();
33988 (arg1)->SetClientSize(arg2,arg3);
33989 wxPyEndAllowThreads(__tstate);
33990 if (PyErr_Occurred()) SWIG_fail;
33991 }
33992 resultobj = SWIG_Py_Void();
33993 return resultobj;
33994 fail:
33995 return NULL;
33996 }
33997
33998
33999 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34000 PyObject *resultobj = 0;
34001 wxWindow *arg1 = (wxWindow *) 0 ;
34002 wxRect *arg2 = 0 ;
34003 void *argp1 = 0 ;
34004 int res1 = 0 ;
34005 wxRect temp2 ;
34006 PyObject * obj0 = 0 ;
34007 PyObject * obj1 = 0 ;
34008 char * kwnames[] = {
34009 (char *) "self",(char *) "rect", NULL
34010 };
34011
34012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
34013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34014 if (!SWIG_IsOK(res1)) {
34015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34016 }
34017 arg1 = reinterpret_cast< wxWindow * >(argp1);
34018 {
34019 arg2 = &temp2;
34020 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34021 }
34022 {
34023 PyThreadState* __tstate = wxPyBeginAllowThreads();
34024 (arg1)->SetClientSize((wxRect const &)*arg2);
34025 wxPyEndAllowThreads(__tstate);
34026 if (PyErr_Occurred()) SWIG_fail;
34027 }
34028 resultobj = SWIG_Py_Void();
34029 return resultobj;
34030 fail:
34031 return NULL;
34032 }
34033
34034
34035 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34036 PyObject *resultobj = 0;
34037 wxWindow *arg1 = (wxWindow *) 0 ;
34038 wxPoint result;
34039 void *argp1 = 0 ;
34040 int res1 = 0 ;
34041 PyObject *swig_obj[1] ;
34042
34043 if (!args) SWIG_fail;
34044 swig_obj[0] = args;
34045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34046 if (!SWIG_IsOK(res1)) {
34047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34048 }
34049 arg1 = reinterpret_cast< wxWindow * >(argp1);
34050 {
34051 PyThreadState* __tstate = wxPyBeginAllowThreads();
34052 result = ((wxWindow const *)arg1)->GetPosition();
34053 wxPyEndAllowThreads(__tstate);
34054 if (PyErr_Occurred()) SWIG_fail;
34055 }
34056 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34057 return resultobj;
34058 fail:
34059 return NULL;
34060 }
34061
34062
34063 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34064 PyObject *resultobj = 0;
34065 wxWindow *arg1 = (wxWindow *) 0 ;
34066 int *arg2 = (int *) 0 ;
34067 int *arg3 = (int *) 0 ;
34068 void *argp1 = 0 ;
34069 int res1 = 0 ;
34070 int temp2 ;
34071 int res2 = SWIG_TMPOBJ ;
34072 int temp3 ;
34073 int res3 = SWIG_TMPOBJ ;
34074 PyObject *swig_obj[1] ;
34075
34076 arg2 = &temp2;
34077 arg3 = &temp3;
34078 if (!args) SWIG_fail;
34079 swig_obj[0] = args;
34080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34081 if (!SWIG_IsOK(res1)) {
34082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34083 }
34084 arg1 = reinterpret_cast< wxWindow * >(argp1);
34085 {
34086 PyThreadState* __tstate = wxPyBeginAllowThreads();
34087 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
34088 wxPyEndAllowThreads(__tstate);
34089 if (PyErr_Occurred()) SWIG_fail;
34090 }
34091 resultobj = SWIG_Py_Void();
34092 if (SWIG_IsTmpObj(res2)) {
34093 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34094 } else {
34095 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34096 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34097 }
34098 if (SWIG_IsTmpObj(res3)) {
34099 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34100 } else {
34101 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34102 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34103 }
34104 return resultobj;
34105 fail:
34106 return NULL;
34107 }
34108
34109
34110 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34111 PyObject *resultobj = 0;
34112 wxWindow *arg1 = (wxWindow *) 0 ;
34113 wxPoint result;
34114 void *argp1 = 0 ;
34115 int res1 = 0 ;
34116 PyObject *swig_obj[1] ;
34117
34118 if (!args) SWIG_fail;
34119 swig_obj[0] = args;
34120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34121 if (!SWIG_IsOK(res1)) {
34122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34123 }
34124 arg1 = reinterpret_cast< wxWindow * >(argp1);
34125 {
34126 PyThreadState* __tstate = wxPyBeginAllowThreads();
34127 result = ((wxWindow const *)arg1)->GetScreenPosition();
34128 wxPyEndAllowThreads(__tstate);
34129 if (PyErr_Occurred()) SWIG_fail;
34130 }
34131 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34132 return resultobj;
34133 fail:
34134 return NULL;
34135 }
34136
34137
34138 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34139 PyObject *resultobj = 0;
34140 wxWindow *arg1 = (wxWindow *) 0 ;
34141 int *arg2 = (int *) 0 ;
34142 int *arg3 = (int *) 0 ;
34143 void *argp1 = 0 ;
34144 int res1 = 0 ;
34145 int temp2 ;
34146 int res2 = SWIG_TMPOBJ ;
34147 int temp3 ;
34148 int res3 = SWIG_TMPOBJ ;
34149 PyObject *swig_obj[1] ;
34150
34151 arg2 = &temp2;
34152 arg3 = &temp3;
34153 if (!args) SWIG_fail;
34154 swig_obj[0] = args;
34155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34156 if (!SWIG_IsOK(res1)) {
34157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34158 }
34159 arg1 = reinterpret_cast< wxWindow * >(argp1);
34160 {
34161 PyThreadState* __tstate = wxPyBeginAllowThreads();
34162 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
34163 wxPyEndAllowThreads(__tstate);
34164 if (PyErr_Occurred()) SWIG_fail;
34165 }
34166 resultobj = SWIG_Py_Void();
34167 if (SWIG_IsTmpObj(res2)) {
34168 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34169 } else {
34170 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34171 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34172 }
34173 if (SWIG_IsTmpObj(res3)) {
34174 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34175 } else {
34176 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34177 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34178 }
34179 return resultobj;
34180 fail:
34181 return NULL;
34182 }
34183
34184
34185 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34186 PyObject *resultobj = 0;
34187 wxWindow *arg1 = (wxWindow *) 0 ;
34188 wxRect result;
34189 void *argp1 = 0 ;
34190 int res1 = 0 ;
34191 PyObject *swig_obj[1] ;
34192
34193 if (!args) SWIG_fail;
34194 swig_obj[0] = args;
34195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34196 if (!SWIG_IsOK(res1)) {
34197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34198 }
34199 arg1 = reinterpret_cast< wxWindow * >(argp1);
34200 {
34201 PyThreadState* __tstate = wxPyBeginAllowThreads();
34202 result = ((wxWindow const *)arg1)->GetScreenRect();
34203 wxPyEndAllowThreads(__tstate);
34204 if (PyErr_Occurred()) SWIG_fail;
34205 }
34206 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34207 return resultobj;
34208 fail:
34209 return NULL;
34210 }
34211
34212
34213 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34214 PyObject *resultobj = 0;
34215 wxWindow *arg1 = (wxWindow *) 0 ;
34216 wxSize result;
34217 void *argp1 = 0 ;
34218 int res1 = 0 ;
34219 PyObject *swig_obj[1] ;
34220
34221 if (!args) SWIG_fail;
34222 swig_obj[0] = args;
34223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34224 if (!SWIG_IsOK(res1)) {
34225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34226 }
34227 arg1 = reinterpret_cast< wxWindow * >(argp1);
34228 {
34229 PyThreadState* __tstate = wxPyBeginAllowThreads();
34230 result = ((wxWindow const *)arg1)->GetSize();
34231 wxPyEndAllowThreads(__tstate);
34232 if (PyErr_Occurred()) SWIG_fail;
34233 }
34234 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34235 return resultobj;
34236 fail:
34237 return NULL;
34238 }
34239
34240
34241 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34242 PyObject *resultobj = 0;
34243 wxWindow *arg1 = (wxWindow *) 0 ;
34244 int *arg2 = (int *) 0 ;
34245 int *arg3 = (int *) 0 ;
34246 void *argp1 = 0 ;
34247 int res1 = 0 ;
34248 int temp2 ;
34249 int res2 = SWIG_TMPOBJ ;
34250 int temp3 ;
34251 int res3 = SWIG_TMPOBJ ;
34252 PyObject *swig_obj[1] ;
34253
34254 arg2 = &temp2;
34255 arg3 = &temp3;
34256 if (!args) SWIG_fail;
34257 swig_obj[0] = args;
34258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34259 if (!SWIG_IsOK(res1)) {
34260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34261 }
34262 arg1 = reinterpret_cast< wxWindow * >(argp1);
34263 {
34264 PyThreadState* __tstate = wxPyBeginAllowThreads();
34265 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
34266 wxPyEndAllowThreads(__tstate);
34267 if (PyErr_Occurred()) SWIG_fail;
34268 }
34269 resultobj = SWIG_Py_Void();
34270 if (SWIG_IsTmpObj(res2)) {
34271 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34272 } else {
34273 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34274 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34275 }
34276 if (SWIG_IsTmpObj(res3)) {
34277 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34278 } else {
34279 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34280 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34281 }
34282 return resultobj;
34283 fail:
34284 return NULL;
34285 }
34286
34287
34288 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34289 PyObject *resultobj = 0;
34290 wxWindow *arg1 = (wxWindow *) 0 ;
34291 wxRect result;
34292 void *argp1 = 0 ;
34293 int res1 = 0 ;
34294 PyObject *swig_obj[1] ;
34295
34296 if (!args) SWIG_fail;
34297 swig_obj[0] = args;
34298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34299 if (!SWIG_IsOK(res1)) {
34300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34301 }
34302 arg1 = reinterpret_cast< wxWindow * >(argp1);
34303 {
34304 PyThreadState* __tstate = wxPyBeginAllowThreads();
34305 result = ((wxWindow const *)arg1)->GetRect();
34306 wxPyEndAllowThreads(__tstate);
34307 if (PyErr_Occurred()) SWIG_fail;
34308 }
34309 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34310 return resultobj;
34311 fail:
34312 return NULL;
34313 }
34314
34315
34316 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34317 PyObject *resultobj = 0;
34318 wxWindow *arg1 = (wxWindow *) 0 ;
34319 wxSize result;
34320 void *argp1 = 0 ;
34321 int res1 = 0 ;
34322 PyObject *swig_obj[1] ;
34323
34324 if (!args) SWIG_fail;
34325 swig_obj[0] = args;
34326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34327 if (!SWIG_IsOK(res1)) {
34328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34329 }
34330 arg1 = reinterpret_cast< wxWindow * >(argp1);
34331 {
34332 PyThreadState* __tstate = wxPyBeginAllowThreads();
34333 result = ((wxWindow const *)arg1)->GetClientSize();
34334 wxPyEndAllowThreads(__tstate);
34335 if (PyErr_Occurred()) SWIG_fail;
34336 }
34337 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34338 return resultobj;
34339 fail:
34340 return NULL;
34341 }
34342
34343
34344 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34345 PyObject *resultobj = 0;
34346 wxWindow *arg1 = (wxWindow *) 0 ;
34347 int *arg2 = (int *) 0 ;
34348 int *arg3 = (int *) 0 ;
34349 void *argp1 = 0 ;
34350 int res1 = 0 ;
34351 int temp2 ;
34352 int res2 = SWIG_TMPOBJ ;
34353 int temp3 ;
34354 int res3 = SWIG_TMPOBJ ;
34355 PyObject *swig_obj[1] ;
34356
34357 arg2 = &temp2;
34358 arg3 = &temp3;
34359 if (!args) SWIG_fail;
34360 swig_obj[0] = args;
34361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34362 if (!SWIG_IsOK(res1)) {
34363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34364 }
34365 arg1 = reinterpret_cast< wxWindow * >(argp1);
34366 {
34367 PyThreadState* __tstate = wxPyBeginAllowThreads();
34368 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
34369 wxPyEndAllowThreads(__tstate);
34370 if (PyErr_Occurred()) SWIG_fail;
34371 }
34372 resultobj = SWIG_Py_Void();
34373 if (SWIG_IsTmpObj(res2)) {
34374 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34375 } else {
34376 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34377 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34378 }
34379 if (SWIG_IsTmpObj(res3)) {
34380 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34381 } else {
34382 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34383 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34384 }
34385 return resultobj;
34386 fail:
34387 return NULL;
34388 }
34389
34390
34391 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34392 PyObject *resultobj = 0;
34393 wxWindow *arg1 = (wxWindow *) 0 ;
34394 wxPoint result;
34395 void *argp1 = 0 ;
34396 int res1 = 0 ;
34397 PyObject *swig_obj[1] ;
34398
34399 if (!args) SWIG_fail;
34400 swig_obj[0] = args;
34401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34402 if (!SWIG_IsOK(res1)) {
34403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
34404 }
34405 arg1 = reinterpret_cast< wxWindow * >(argp1);
34406 {
34407 PyThreadState* __tstate = wxPyBeginAllowThreads();
34408 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
34409 wxPyEndAllowThreads(__tstate);
34410 if (PyErr_Occurred()) SWIG_fail;
34411 }
34412 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34413 return resultobj;
34414 fail:
34415 return NULL;
34416 }
34417
34418
34419 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34420 PyObject *resultobj = 0;
34421 wxWindow *arg1 = (wxWindow *) 0 ;
34422 wxRect result;
34423 void *argp1 = 0 ;
34424 int res1 = 0 ;
34425 PyObject *swig_obj[1] ;
34426
34427 if (!args) SWIG_fail;
34428 swig_obj[0] = args;
34429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34430 if (!SWIG_IsOK(res1)) {
34431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34432 }
34433 arg1 = reinterpret_cast< wxWindow * >(argp1);
34434 {
34435 PyThreadState* __tstate = wxPyBeginAllowThreads();
34436 result = ((wxWindow const *)arg1)->GetClientRect();
34437 wxPyEndAllowThreads(__tstate);
34438 if (PyErr_Occurred()) SWIG_fail;
34439 }
34440 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34441 return resultobj;
34442 fail:
34443 return NULL;
34444 }
34445
34446
34447 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34448 PyObject *resultobj = 0;
34449 wxWindow *arg1 = (wxWindow *) 0 ;
34450 wxSize result;
34451 void *argp1 = 0 ;
34452 int res1 = 0 ;
34453 PyObject *swig_obj[1] ;
34454
34455 if (!args) SWIG_fail;
34456 swig_obj[0] = args;
34457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34458 if (!SWIG_IsOK(res1)) {
34459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34460 }
34461 arg1 = reinterpret_cast< wxWindow * >(argp1);
34462 {
34463 PyThreadState* __tstate = wxPyBeginAllowThreads();
34464 result = ((wxWindow const *)arg1)->GetBestSize();
34465 wxPyEndAllowThreads(__tstate);
34466 if (PyErr_Occurred()) SWIG_fail;
34467 }
34468 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34469 return resultobj;
34470 fail:
34471 return NULL;
34472 }
34473
34474
34475 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34476 PyObject *resultobj = 0;
34477 wxWindow *arg1 = (wxWindow *) 0 ;
34478 int *arg2 = (int *) 0 ;
34479 int *arg3 = (int *) 0 ;
34480 void *argp1 = 0 ;
34481 int res1 = 0 ;
34482 int temp2 ;
34483 int res2 = SWIG_TMPOBJ ;
34484 int temp3 ;
34485 int res3 = SWIG_TMPOBJ ;
34486 PyObject *swig_obj[1] ;
34487
34488 arg2 = &temp2;
34489 arg3 = &temp3;
34490 if (!args) SWIG_fail;
34491 swig_obj[0] = args;
34492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34493 if (!SWIG_IsOK(res1)) {
34494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34495 }
34496 arg1 = reinterpret_cast< wxWindow * >(argp1);
34497 {
34498 PyThreadState* __tstate = wxPyBeginAllowThreads();
34499 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
34500 wxPyEndAllowThreads(__tstate);
34501 if (PyErr_Occurred()) SWIG_fail;
34502 }
34503 resultobj = SWIG_Py_Void();
34504 if (SWIG_IsTmpObj(res2)) {
34505 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34506 } else {
34507 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34508 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34509 }
34510 if (SWIG_IsTmpObj(res3)) {
34511 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34512 } else {
34513 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34514 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34515 }
34516 return resultobj;
34517 fail:
34518 return NULL;
34519 }
34520
34521
34522 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34523 PyObject *resultobj = 0;
34524 wxWindow *arg1 = (wxWindow *) 0 ;
34525 void *argp1 = 0 ;
34526 int res1 = 0 ;
34527 PyObject *swig_obj[1] ;
34528
34529 if (!args) SWIG_fail;
34530 swig_obj[0] = args;
34531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34532 if (!SWIG_IsOK(res1)) {
34533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34534 }
34535 arg1 = reinterpret_cast< wxWindow * >(argp1);
34536 {
34537 PyThreadState* __tstate = wxPyBeginAllowThreads();
34538 (arg1)->InvalidateBestSize();
34539 wxPyEndAllowThreads(__tstate);
34540 if (PyErr_Occurred()) SWIG_fail;
34541 }
34542 resultobj = SWIG_Py_Void();
34543 return resultobj;
34544 fail:
34545 return NULL;
34546 }
34547
34548
34549 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34550 PyObject *resultobj = 0;
34551 wxWindow *arg1 = (wxWindow *) 0 ;
34552 wxSize *arg2 = 0 ;
34553 void *argp1 = 0 ;
34554 int res1 = 0 ;
34555 wxSize temp2 ;
34556 PyObject * obj0 = 0 ;
34557 PyObject * obj1 = 0 ;
34558 char * kwnames[] = {
34559 (char *) "self",(char *) "size", NULL
34560 };
34561
34562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
34563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34564 if (!SWIG_IsOK(res1)) {
34565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34566 }
34567 arg1 = reinterpret_cast< wxWindow * >(argp1);
34568 {
34569 arg2 = &temp2;
34570 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34571 }
34572 {
34573 PyThreadState* __tstate = wxPyBeginAllowThreads();
34574 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
34575 wxPyEndAllowThreads(__tstate);
34576 if (PyErr_Occurred()) SWIG_fail;
34577 }
34578 resultobj = SWIG_Py_Void();
34579 return resultobj;
34580 fail:
34581 return NULL;
34582 }
34583
34584
34585 SWIGINTERN PyObject *_wrap_Window_GetEffectiveMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34586 PyObject *resultobj = 0;
34587 wxWindow *arg1 = (wxWindow *) 0 ;
34588 wxSize result;
34589 void *argp1 = 0 ;
34590 int res1 = 0 ;
34591 PyObject *swig_obj[1] ;
34592
34593 if (!args) SWIG_fail;
34594 swig_obj[0] = args;
34595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34596 if (!SWIG_IsOK(res1)) {
34597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEffectiveMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34598 }
34599 arg1 = reinterpret_cast< wxWindow * >(argp1);
34600 {
34601 PyThreadState* __tstate = wxPyBeginAllowThreads();
34602 result = ((wxWindow const *)arg1)->GetEffectiveMinSize();
34603 wxPyEndAllowThreads(__tstate);
34604 if (PyErr_Occurred()) SWIG_fail;
34605 }
34606 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34607 return resultobj;
34608 fail:
34609 return NULL;
34610 }
34611
34612
34613 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34614 PyObject *resultobj = 0;
34615 wxWindow *arg1 = (wxWindow *) 0 ;
34616 int arg2 = (int) wxBOTH ;
34617 void *argp1 = 0 ;
34618 int res1 = 0 ;
34619 int val2 ;
34620 int ecode2 = 0 ;
34621 PyObject * obj0 = 0 ;
34622 PyObject * obj1 = 0 ;
34623 char * kwnames[] = {
34624 (char *) "self",(char *) "direction", NULL
34625 };
34626
34627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
34628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34629 if (!SWIG_IsOK(res1)) {
34630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
34631 }
34632 arg1 = reinterpret_cast< wxWindow * >(argp1);
34633 if (obj1) {
34634 ecode2 = SWIG_AsVal_int(obj1, &val2);
34635 if (!SWIG_IsOK(ecode2)) {
34636 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
34637 }
34638 arg2 = static_cast< int >(val2);
34639 }
34640 {
34641 PyThreadState* __tstate = wxPyBeginAllowThreads();
34642 (arg1)->Center(arg2);
34643 wxPyEndAllowThreads(__tstate);
34644 if (PyErr_Occurred()) SWIG_fail;
34645 }
34646 resultobj = SWIG_Py_Void();
34647 return resultobj;
34648 fail:
34649 return NULL;
34650 }
34651
34652
34653 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34654 PyObject *resultobj = 0;
34655 wxWindow *arg1 = (wxWindow *) 0 ;
34656 int arg2 = (int) wxBOTH ;
34657 void *argp1 = 0 ;
34658 int res1 = 0 ;
34659 int val2 ;
34660 int ecode2 = 0 ;
34661 PyObject * obj0 = 0 ;
34662 PyObject * obj1 = 0 ;
34663 char * kwnames[] = {
34664 (char *) "self",(char *) "dir", NULL
34665 };
34666
34667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
34668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34669 if (!SWIG_IsOK(res1)) {
34670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
34671 }
34672 arg1 = reinterpret_cast< wxWindow * >(argp1);
34673 if (obj1) {
34674 ecode2 = SWIG_AsVal_int(obj1, &val2);
34675 if (!SWIG_IsOK(ecode2)) {
34676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
34677 }
34678 arg2 = static_cast< int >(val2);
34679 }
34680 {
34681 PyThreadState* __tstate = wxPyBeginAllowThreads();
34682 (arg1)->CenterOnParent(arg2);
34683 wxPyEndAllowThreads(__tstate);
34684 if (PyErr_Occurred()) SWIG_fail;
34685 }
34686 resultobj = SWIG_Py_Void();
34687 return resultobj;
34688 fail:
34689 return NULL;
34690 }
34691
34692
34693 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34694 PyObject *resultobj = 0;
34695 wxWindow *arg1 = (wxWindow *) 0 ;
34696 void *argp1 = 0 ;
34697 int res1 = 0 ;
34698 PyObject *swig_obj[1] ;
34699
34700 if (!args) SWIG_fail;
34701 swig_obj[0] = args;
34702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34703 if (!SWIG_IsOK(res1)) {
34704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
34705 }
34706 arg1 = reinterpret_cast< wxWindow * >(argp1);
34707 {
34708 PyThreadState* __tstate = wxPyBeginAllowThreads();
34709 (arg1)->Fit();
34710 wxPyEndAllowThreads(__tstate);
34711 if (PyErr_Occurred()) SWIG_fail;
34712 }
34713 resultobj = SWIG_Py_Void();
34714 return resultobj;
34715 fail:
34716 return NULL;
34717 }
34718
34719
34720 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34721 PyObject *resultobj = 0;
34722 wxWindow *arg1 = (wxWindow *) 0 ;
34723 void *argp1 = 0 ;
34724 int res1 = 0 ;
34725 PyObject *swig_obj[1] ;
34726
34727 if (!args) SWIG_fail;
34728 swig_obj[0] = args;
34729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34730 if (!SWIG_IsOK(res1)) {
34731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
34732 }
34733 arg1 = reinterpret_cast< wxWindow * >(argp1);
34734 {
34735 PyThreadState* __tstate = wxPyBeginAllowThreads();
34736 (arg1)->FitInside();
34737 wxPyEndAllowThreads(__tstate);
34738 if (PyErr_Occurred()) SWIG_fail;
34739 }
34740 resultobj = SWIG_Py_Void();
34741 return resultobj;
34742 fail:
34743 return NULL;
34744 }
34745
34746
34747 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34748 PyObject *resultobj = 0;
34749 wxWindow *arg1 = (wxWindow *) 0 ;
34750 int arg2 ;
34751 int arg3 ;
34752 int arg4 = (int) -1 ;
34753 int arg5 = (int) -1 ;
34754 int arg6 = (int) -1 ;
34755 int arg7 = (int) -1 ;
34756 void *argp1 = 0 ;
34757 int res1 = 0 ;
34758 int val2 ;
34759 int ecode2 = 0 ;
34760 int val3 ;
34761 int ecode3 = 0 ;
34762 int val4 ;
34763 int ecode4 = 0 ;
34764 int val5 ;
34765 int ecode5 = 0 ;
34766 int val6 ;
34767 int ecode6 = 0 ;
34768 int val7 ;
34769 int ecode7 = 0 ;
34770 PyObject * obj0 = 0 ;
34771 PyObject * obj1 = 0 ;
34772 PyObject * obj2 = 0 ;
34773 PyObject * obj3 = 0 ;
34774 PyObject * obj4 = 0 ;
34775 PyObject * obj5 = 0 ;
34776 PyObject * obj6 = 0 ;
34777 char * kwnames[] = {
34778 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
34779 };
34780
34781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
34782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34783 if (!SWIG_IsOK(res1)) {
34784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34785 }
34786 arg1 = reinterpret_cast< wxWindow * >(argp1);
34787 ecode2 = SWIG_AsVal_int(obj1, &val2);
34788 if (!SWIG_IsOK(ecode2)) {
34789 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
34790 }
34791 arg2 = static_cast< int >(val2);
34792 ecode3 = SWIG_AsVal_int(obj2, &val3);
34793 if (!SWIG_IsOK(ecode3)) {
34794 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
34795 }
34796 arg3 = static_cast< int >(val3);
34797 if (obj3) {
34798 ecode4 = SWIG_AsVal_int(obj3, &val4);
34799 if (!SWIG_IsOK(ecode4)) {
34800 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
34801 }
34802 arg4 = static_cast< int >(val4);
34803 }
34804 if (obj4) {
34805 ecode5 = SWIG_AsVal_int(obj4, &val5);
34806 if (!SWIG_IsOK(ecode5)) {
34807 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
34808 }
34809 arg5 = static_cast< int >(val5);
34810 }
34811 if (obj5) {
34812 ecode6 = SWIG_AsVal_int(obj5, &val6);
34813 if (!SWIG_IsOK(ecode6)) {
34814 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
34815 }
34816 arg6 = static_cast< int >(val6);
34817 }
34818 if (obj6) {
34819 ecode7 = SWIG_AsVal_int(obj6, &val7);
34820 if (!SWIG_IsOK(ecode7)) {
34821 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
34822 }
34823 arg7 = static_cast< int >(val7);
34824 }
34825 {
34826 PyThreadState* __tstate = wxPyBeginAllowThreads();
34827 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
34828 wxPyEndAllowThreads(__tstate);
34829 if (PyErr_Occurred()) SWIG_fail;
34830 }
34831 resultobj = SWIG_Py_Void();
34832 return resultobj;
34833 fail:
34834 return NULL;
34835 }
34836
34837
34838 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34839 PyObject *resultobj = 0;
34840 wxWindow *arg1 = (wxWindow *) 0 ;
34841 wxSize *arg2 = 0 ;
34842 wxSize const &arg3_defvalue = wxDefaultSize ;
34843 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
34844 wxSize const &arg4_defvalue = wxDefaultSize ;
34845 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
34846 void *argp1 = 0 ;
34847 int res1 = 0 ;
34848 wxSize temp2 ;
34849 wxSize temp3 ;
34850 wxSize temp4 ;
34851 PyObject * obj0 = 0 ;
34852 PyObject * obj1 = 0 ;
34853 PyObject * obj2 = 0 ;
34854 PyObject * obj3 = 0 ;
34855 char * kwnames[] = {
34856 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
34857 };
34858
34859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34861 if (!SWIG_IsOK(res1)) {
34862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
34863 }
34864 arg1 = reinterpret_cast< wxWindow * >(argp1);
34865 {
34866 arg2 = &temp2;
34867 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34868 }
34869 if (obj2) {
34870 {
34871 arg3 = &temp3;
34872 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
34873 }
34874 }
34875 if (obj3) {
34876 {
34877 arg4 = &temp4;
34878 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
34879 }
34880 }
34881 {
34882 PyThreadState* __tstate = wxPyBeginAllowThreads();
34883 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
34884 wxPyEndAllowThreads(__tstate);
34885 if (PyErr_Occurred()) SWIG_fail;
34886 }
34887 resultobj = SWIG_Py_Void();
34888 return resultobj;
34889 fail:
34890 return NULL;
34891 }
34892
34893
34894 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34895 PyObject *resultobj = 0;
34896 wxWindow *arg1 = (wxWindow *) 0 ;
34897 int arg2 ;
34898 int arg3 ;
34899 int arg4 = (int) -1 ;
34900 int arg5 = (int) -1 ;
34901 void *argp1 = 0 ;
34902 int res1 = 0 ;
34903 int val2 ;
34904 int ecode2 = 0 ;
34905 int val3 ;
34906 int ecode3 = 0 ;
34907 int val4 ;
34908 int ecode4 = 0 ;
34909 int val5 ;
34910 int ecode5 = 0 ;
34911 PyObject * obj0 = 0 ;
34912 PyObject * obj1 = 0 ;
34913 PyObject * obj2 = 0 ;
34914 PyObject * obj3 = 0 ;
34915 PyObject * obj4 = 0 ;
34916 char * kwnames[] = {
34917 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
34918 };
34919
34920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34922 if (!SWIG_IsOK(res1)) {
34923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34924 }
34925 arg1 = reinterpret_cast< wxWindow * >(argp1);
34926 ecode2 = SWIG_AsVal_int(obj1, &val2);
34927 if (!SWIG_IsOK(ecode2)) {
34928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
34929 }
34930 arg2 = static_cast< int >(val2);
34931 ecode3 = SWIG_AsVal_int(obj2, &val3);
34932 if (!SWIG_IsOK(ecode3)) {
34933 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
34934 }
34935 arg3 = static_cast< int >(val3);
34936 if (obj3) {
34937 ecode4 = SWIG_AsVal_int(obj3, &val4);
34938 if (!SWIG_IsOK(ecode4)) {
34939 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
34940 }
34941 arg4 = static_cast< int >(val4);
34942 }
34943 if (obj4) {
34944 ecode5 = SWIG_AsVal_int(obj4, &val5);
34945 if (!SWIG_IsOK(ecode5)) {
34946 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
34947 }
34948 arg5 = static_cast< int >(val5);
34949 }
34950 {
34951 PyThreadState* __tstate = wxPyBeginAllowThreads();
34952 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
34953 wxPyEndAllowThreads(__tstate);
34954 if (PyErr_Occurred()) SWIG_fail;
34955 }
34956 resultobj = SWIG_Py_Void();
34957 return resultobj;
34958 fail:
34959 return NULL;
34960 }
34961
34962
34963 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34964 PyObject *resultobj = 0;
34965 wxWindow *arg1 = (wxWindow *) 0 ;
34966 wxSize *arg2 = 0 ;
34967 wxSize const &arg3_defvalue = wxDefaultSize ;
34968 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
34969 void *argp1 = 0 ;
34970 int res1 = 0 ;
34971 wxSize temp2 ;
34972 wxSize temp3 ;
34973 PyObject * obj0 = 0 ;
34974 PyObject * obj1 = 0 ;
34975 PyObject * obj2 = 0 ;
34976 char * kwnames[] = {
34977 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
34978 };
34979
34980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34982 if (!SWIG_IsOK(res1)) {
34983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
34984 }
34985 arg1 = reinterpret_cast< wxWindow * >(argp1);
34986 {
34987 arg2 = &temp2;
34988 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34989 }
34990 if (obj2) {
34991 {
34992 arg3 = &temp3;
34993 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
34994 }
34995 }
34996 {
34997 PyThreadState* __tstate = wxPyBeginAllowThreads();
34998 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
34999 wxPyEndAllowThreads(__tstate);
35000 if (PyErr_Occurred()) SWIG_fail;
35001 }
35002 resultobj = SWIG_Py_Void();
35003 return resultobj;
35004 fail:
35005 return NULL;
35006 }
35007
35008
35009 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35010 PyObject *resultobj = 0;
35011 wxWindow *arg1 = (wxWindow *) 0 ;
35012 wxSize result;
35013 void *argp1 = 0 ;
35014 int res1 = 0 ;
35015 PyObject *swig_obj[1] ;
35016
35017 if (!args) SWIG_fail;
35018 swig_obj[0] = args;
35019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35020 if (!SWIG_IsOK(res1)) {
35021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35022 }
35023 arg1 = reinterpret_cast< wxWindow * >(argp1);
35024 {
35025 PyThreadState* __tstate = wxPyBeginAllowThreads();
35026 result = ((wxWindow const *)arg1)->GetMaxSize();
35027 wxPyEndAllowThreads(__tstate);
35028 if (PyErr_Occurred()) SWIG_fail;
35029 }
35030 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35031 return resultobj;
35032 fail:
35033 return NULL;
35034 }
35035
35036
35037 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35038 PyObject *resultobj = 0;
35039 wxWindow *arg1 = (wxWindow *) 0 ;
35040 wxSize result;
35041 void *argp1 = 0 ;
35042 int res1 = 0 ;
35043 PyObject *swig_obj[1] ;
35044
35045 if (!args) SWIG_fail;
35046 swig_obj[0] = args;
35047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35048 if (!SWIG_IsOK(res1)) {
35049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35050 }
35051 arg1 = reinterpret_cast< wxWindow * >(argp1);
35052 {
35053 PyThreadState* __tstate = wxPyBeginAllowThreads();
35054 result = ((wxWindow const *)arg1)->GetMinSize();
35055 wxPyEndAllowThreads(__tstate);
35056 if (PyErr_Occurred()) SWIG_fail;
35057 }
35058 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35059 return resultobj;
35060 fail:
35061 return NULL;
35062 }
35063
35064
35065 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35066 PyObject *resultobj = 0;
35067 wxWindow *arg1 = (wxWindow *) 0 ;
35068 wxSize *arg2 = 0 ;
35069 void *argp1 = 0 ;
35070 int res1 = 0 ;
35071 wxSize temp2 ;
35072 PyObject * obj0 = 0 ;
35073 PyObject * obj1 = 0 ;
35074 char * kwnames[] = {
35075 (char *) "self",(char *) "minSize", NULL
35076 };
35077
35078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
35079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35080 if (!SWIG_IsOK(res1)) {
35081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35082 }
35083 arg1 = reinterpret_cast< wxWindow * >(argp1);
35084 {
35085 arg2 = &temp2;
35086 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35087 }
35088 {
35089 PyThreadState* __tstate = wxPyBeginAllowThreads();
35090 (arg1)->SetMinSize((wxSize const &)*arg2);
35091 wxPyEndAllowThreads(__tstate);
35092 if (PyErr_Occurred()) SWIG_fail;
35093 }
35094 resultobj = SWIG_Py_Void();
35095 return resultobj;
35096 fail:
35097 return NULL;
35098 }
35099
35100
35101 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35102 PyObject *resultobj = 0;
35103 wxWindow *arg1 = (wxWindow *) 0 ;
35104 wxSize *arg2 = 0 ;
35105 void *argp1 = 0 ;
35106 int res1 = 0 ;
35107 wxSize temp2 ;
35108 PyObject * obj0 = 0 ;
35109 PyObject * obj1 = 0 ;
35110 char * kwnames[] = {
35111 (char *) "self",(char *) "maxSize", NULL
35112 };
35113
35114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
35115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35116 if (!SWIG_IsOK(res1)) {
35117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35118 }
35119 arg1 = reinterpret_cast< wxWindow * >(argp1);
35120 {
35121 arg2 = &temp2;
35122 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35123 }
35124 {
35125 PyThreadState* __tstate = wxPyBeginAllowThreads();
35126 (arg1)->SetMaxSize((wxSize const &)*arg2);
35127 wxPyEndAllowThreads(__tstate);
35128 if (PyErr_Occurred()) SWIG_fail;
35129 }
35130 resultobj = SWIG_Py_Void();
35131 return resultobj;
35132 fail:
35133 return NULL;
35134 }
35135
35136
35137 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35138 PyObject *resultobj = 0;
35139 wxWindow *arg1 = (wxWindow *) 0 ;
35140 int result;
35141 void *argp1 = 0 ;
35142 int res1 = 0 ;
35143 PyObject *swig_obj[1] ;
35144
35145 if (!args) SWIG_fail;
35146 swig_obj[0] = args;
35147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35148 if (!SWIG_IsOK(res1)) {
35149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35150 }
35151 arg1 = reinterpret_cast< wxWindow * >(argp1);
35152 {
35153 PyThreadState* __tstate = wxPyBeginAllowThreads();
35154 result = (int)((wxWindow const *)arg1)->GetMinWidth();
35155 wxPyEndAllowThreads(__tstate);
35156 if (PyErr_Occurred()) SWIG_fail;
35157 }
35158 resultobj = SWIG_From_int(static_cast< int >(result));
35159 return resultobj;
35160 fail:
35161 return NULL;
35162 }
35163
35164
35165 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35166 PyObject *resultobj = 0;
35167 wxWindow *arg1 = (wxWindow *) 0 ;
35168 int result;
35169 void *argp1 = 0 ;
35170 int res1 = 0 ;
35171 PyObject *swig_obj[1] ;
35172
35173 if (!args) SWIG_fail;
35174 swig_obj[0] = args;
35175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35176 if (!SWIG_IsOK(res1)) {
35177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35178 }
35179 arg1 = reinterpret_cast< wxWindow * >(argp1);
35180 {
35181 PyThreadState* __tstate = wxPyBeginAllowThreads();
35182 result = (int)((wxWindow const *)arg1)->GetMinHeight();
35183 wxPyEndAllowThreads(__tstate);
35184 if (PyErr_Occurred()) SWIG_fail;
35185 }
35186 resultobj = SWIG_From_int(static_cast< int >(result));
35187 return resultobj;
35188 fail:
35189 return NULL;
35190 }
35191
35192
35193 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35194 PyObject *resultobj = 0;
35195 wxWindow *arg1 = (wxWindow *) 0 ;
35196 int result;
35197 void *argp1 = 0 ;
35198 int res1 = 0 ;
35199 PyObject *swig_obj[1] ;
35200
35201 if (!args) SWIG_fail;
35202 swig_obj[0] = args;
35203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35204 if (!SWIG_IsOK(res1)) {
35205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35206 }
35207 arg1 = reinterpret_cast< wxWindow * >(argp1);
35208 {
35209 PyThreadState* __tstate = wxPyBeginAllowThreads();
35210 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
35211 wxPyEndAllowThreads(__tstate);
35212 if (PyErr_Occurred()) SWIG_fail;
35213 }
35214 resultobj = SWIG_From_int(static_cast< int >(result));
35215 return resultobj;
35216 fail:
35217 return NULL;
35218 }
35219
35220
35221 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35222 PyObject *resultobj = 0;
35223 wxWindow *arg1 = (wxWindow *) 0 ;
35224 int result;
35225 void *argp1 = 0 ;
35226 int res1 = 0 ;
35227 PyObject *swig_obj[1] ;
35228
35229 if (!args) SWIG_fail;
35230 swig_obj[0] = args;
35231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35232 if (!SWIG_IsOK(res1)) {
35233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35234 }
35235 arg1 = reinterpret_cast< wxWindow * >(argp1);
35236 {
35237 PyThreadState* __tstate = wxPyBeginAllowThreads();
35238 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
35239 wxPyEndAllowThreads(__tstate);
35240 if (PyErr_Occurred()) SWIG_fail;
35241 }
35242 resultobj = SWIG_From_int(static_cast< int >(result));
35243 return resultobj;
35244 fail:
35245 return NULL;
35246 }
35247
35248
35249 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35250 PyObject *resultobj = 0;
35251 wxWindow *arg1 = (wxWindow *) 0 ;
35252 wxSize *arg2 = 0 ;
35253 void *argp1 = 0 ;
35254 int res1 = 0 ;
35255 wxSize temp2 ;
35256 PyObject * obj0 = 0 ;
35257 PyObject * obj1 = 0 ;
35258 char * kwnames[] = {
35259 (char *) "self",(char *) "size", NULL
35260 };
35261
35262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
35263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35264 if (!SWIG_IsOK(res1)) {
35265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35266 }
35267 arg1 = reinterpret_cast< wxWindow * >(argp1);
35268 {
35269 arg2 = &temp2;
35270 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35271 }
35272 {
35273 PyThreadState* __tstate = wxPyBeginAllowThreads();
35274 (arg1)->SetVirtualSize((wxSize const &)*arg2);
35275 wxPyEndAllowThreads(__tstate);
35276 if (PyErr_Occurred()) SWIG_fail;
35277 }
35278 resultobj = SWIG_Py_Void();
35279 return resultobj;
35280 fail:
35281 return NULL;
35282 }
35283
35284
35285 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35286 PyObject *resultobj = 0;
35287 wxWindow *arg1 = (wxWindow *) 0 ;
35288 int arg2 ;
35289 int arg3 ;
35290 void *argp1 = 0 ;
35291 int res1 = 0 ;
35292 int val2 ;
35293 int ecode2 = 0 ;
35294 int val3 ;
35295 int ecode3 = 0 ;
35296 PyObject * obj0 = 0 ;
35297 PyObject * obj1 = 0 ;
35298 PyObject * obj2 = 0 ;
35299 char * kwnames[] = {
35300 (char *) "self",(char *) "w",(char *) "h", NULL
35301 };
35302
35303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35305 if (!SWIG_IsOK(res1)) {
35306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
35307 }
35308 arg1 = reinterpret_cast< wxWindow * >(argp1);
35309 ecode2 = SWIG_AsVal_int(obj1, &val2);
35310 if (!SWIG_IsOK(ecode2)) {
35311 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
35312 }
35313 arg2 = static_cast< int >(val2);
35314 ecode3 = SWIG_AsVal_int(obj2, &val3);
35315 if (!SWIG_IsOK(ecode3)) {
35316 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
35317 }
35318 arg3 = static_cast< int >(val3);
35319 {
35320 PyThreadState* __tstate = wxPyBeginAllowThreads();
35321 (arg1)->SetVirtualSize(arg2,arg3);
35322 wxPyEndAllowThreads(__tstate);
35323 if (PyErr_Occurred()) SWIG_fail;
35324 }
35325 resultobj = SWIG_Py_Void();
35326 return resultobj;
35327 fail:
35328 return NULL;
35329 }
35330
35331
35332 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35333 PyObject *resultobj = 0;
35334 wxWindow *arg1 = (wxWindow *) 0 ;
35335 wxSize result;
35336 void *argp1 = 0 ;
35337 int res1 = 0 ;
35338 PyObject *swig_obj[1] ;
35339
35340 if (!args) SWIG_fail;
35341 swig_obj[0] = args;
35342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35343 if (!SWIG_IsOK(res1)) {
35344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35345 }
35346 arg1 = reinterpret_cast< wxWindow * >(argp1);
35347 {
35348 PyThreadState* __tstate = wxPyBeginAllowThreads();
35349 result = ((wxWindow const *)arg1)->GetVirtualSize();
35350 wxPyEndAllowThreads(__tstate);
35351 if (PyErr_Occurred()) SWIG_fail;
35352 }
35353 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35354 return resultobj;
35355 fail:
35356 return NULL;
35357 }
35358
35359
35360 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35361 PyObject *resultobj = 0;
35362 wxWindow *arg1 = (wxWindow *) 0 ;
35363 int *arg2 = (int *) 0 ;
35364 int *arg3 = (int *) 0 ;
35365 void *argp1 = 0 ;
35366 int res1 = 0 ;
35367 int temp2 ;
35368 int res2 = SWIG_TMPOBJ ;
35369 int temp3 ;
35370 int res3 = SWIG_TMPOBJ ;
35371 PyObject *swig_obj[1] ;
35372
35373 arg2 = &temp2;
35374 arg3 = &temp3;
35375 if (!args) SWIG_fail;
35376 swig_obj[0] = args;
35377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35378 if (!SWIG_IsOK(res1)) {
35379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
35380 }
35381 arg1 = reinterpret_cast< wxWindow * >(argp1);
35382 {
35383 PyThreadState* __tstate = wxPyBeginAllowThreads();
35384 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
35385 wxPyEndAllowThreads(__tstate);
35386 if (PyErr_Occurred()) SWIG_fail;
35387 }
35388 resultobj = SWIG_Py_Void();
35389 if (SWIG_IsTmpObj(res2)) {
35390 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35391 } else {
35392 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35393 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35394 }
35395 if (SWIG_IsTmpObj(res3)) {
35396 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35397 } else {
35398 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35399 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35400 }
35401 return resultobj;
35402 fail:
35403 return NULL;
35404 }
35405
35406
35407 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35408 PyObject *resultobj = 0;
35409 wxWindow *arg1 = (wxWindow *) 0 ;
35410 wxSize result;
35411 void *argp1 = 0 ;
35412 int res1 = 0 ;
35413 PyObject *swig_obj[1] ;
35414
35415 if (!args) SWIG_fail;
35416 swig_obj[0] = args;
35417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35418 if (!SWIG_IsOK(res1)) {
35419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35420 }
35421 arg1 = reinterpret_cast< wxWindow * >(argp1);
35422 {
35423 PyThreadState* __tstate = wxPyBeginAllowThreads();
35424 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
35425 wxPyEndAllowThreads(__tstate);
35426 if (PyErr_Occurred()) SWIG_fail;
35427 }
35428 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35429 return resultobj;
35430 fail:
35431 return NULL;
35432 }
35433
35434
35435 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35436 PyObject *resultobj = 0;
35437 wxWindow *arg1 = (wxWindow *) 0 ;
35438 bool arg2 = (bool) true ;
35439 bool result;
35440 void *argp1 = 0 ;
35441 int res1 = 0 ;
35442 bool val2 ;
35443 int ecode2 = 0 ;
35444 PyObject * obj0 = 0 ;
35445 PyObject * obj1 = 0 ;
35446 char * kwnames[] = {
35447 (char *) "self",(char *) "show", NULL
35448 };
35449
35450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
35451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35452 if (!SWIG_IsOK(res1)) {
35453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
35454 }
35455 arg1 = reinterpret_cast< wxWindow * >(argp1);
35456 if (obj1) {
35457 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35458 if (!SWIG_IsOK(ecode2)) {
35459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
35460 }
35461 arg2 = static_cast< bool >(val2);
35462 }
35463 {
35464 PyThreadState* __tstate = wxPyBeginAllowThreads();
35465 result = (bool)(arg1)->Show(arg2);
35466 wxPyEndAllowThreads(__tstate);
35467 if (PyErr_Occurred()) SWIG_fail;
35468 }
35469 {
35470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35471 }
35472 return resultobj;
35473 fail:
35474 return NULL;
35475 }
35476
35477
35478 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35479 PyObject *resultobj = 0;
35480 wxWindow *arg1 = (wxWindow *) 0 ;
35481 bool result;
35482 void *argp1 = 0 ;
35483 int res1 = 0 ;
35484 PyObject *swig_obj[1] ;
35485
35486 if (!args) SWIG_fail;
35487 swig_obj[0] = args;
35488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35489 if (!SWIG_IsOK(res1)) {
35490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
35491 }
35492 arg1 = reinterpret_cast< wxWindow * >(argp1);
35493 {
35494 PyThreadState* __tstate = wxPyBeginAllowThreads();
35495 result = (bool)(arg1)->Hide();
35496 wxPyEndAllowThreads(__tstate);
35497 if (PyErr_Occurred()) SWIG_fail;
35498 }
35499 {
35500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35501 }
35502 return resultobj;
35503 fail:
35504 return NULL;
35505 }
35506
35507
35508 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35509 PyObject *resultobj = 0;
35510 wxWindow *arg1 = (wxWindow *) 0 ;
35511 bool arg2 = (bool) true ;
35512 bool result;
35513 void *argp1 = 0 ;
35514 int res1 = 0 ;
35515 bool val2 ;
35516 int ecode2 = 0 ;
35517 PyObject * obj0 = 0 ;
35518 PyObject * obj1 = 0 ;
35519 char * kwnames[] = {
35520 (char *) "self",(char *) "enable", NULL
35521 };
35522
35523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
35524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35525 if (!SWIG_IsOK(res1)) {
35526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
35527 }
35528 arg1 = reinterpret_cast< wxWindow * >(argp1);
35529 if (obj1) {
35530 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35531 if (!SWIG_IsOK(ecode2)) {
35532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
35533 }
35534 arg2 = static_cast< bool >(val2);
35535 }
35536 {
35537 PyThreadState* __tstate = wxPyBeginAllowThreads();
35538 result = (bool)(arg1)->Enable(arg2);
35539 wxPyEndAllowThreads(__tstate);
35540 if (PyErr_Occurred()) SWIG_fail;
35541 }
35542 {
35543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35544 }
35545 return resultobj;
35546 fail:
35547 return NULL;
35548 }
35549
35550
35551 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35552 PyObject *resultobj = 0;
35553 wxWindow *arg1 = (wxWindow *) 0 ;
35554 bool result;
35555 void *argp1 = 0 ;
35556 int res1 = 0 ;
35557 PyObject *swig_obj[1] ;
35558
35559 if (!args) SWIG_fail;
35560 swig_obj[0] = args;
35561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35562 if (!SWIG_IsOK(res1)) {
35563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
35564 }
35565 arg1 = reinterpret_cast< wxWindow * >(argp1);
35566 {
35567 PyThreadState* __tstate = wxPyBeginAllowThreads();
35568 result = (bool)(arg1)->Disable();
35569 wxPyEndAllowThreads(__tstate);
35570 if (PyErr_Occurred()) SWIG_fail;
35571 }
35572 {
35573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35574 }
35575 return resultobj;
35576 fail:
35577 return NULL;
35578 }
35579
35580
35581 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35582 PyObject *resultobj = 0;
35583 wxWindow *arg1 = (wxWindow *) 0 ;
35584 bool result;
35585 void *argp1 = 0 ;
35586 int res1 = 0 ;
35587 PyObject *swig_obj[1] ;
35588
35589 if (!args) SWIG_fail;
35590 swig_obj[0] = args;
35591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35592 if (!SWIG_IsOK(res1)) {
35593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
35594 }
35595 arg1 = reinterpret_cast< wxWindow * >(argp1);
35596 {
35597 PyThreadState* __tstate = wxPyBeginAllowThreads();
35598 result = (bool)((wxWindow const *)arg1)->IsShown();
35599 wxPyEndAllowThreads(__tstate);
35600 if (PyErr_Occurred()) SWIG_fail;
35601 }
35602 {
35603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35604 }
35605 return resultobj;
35606 fail:
35607 return NULL;
35608 }
35609
35610
35611 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35612 PyObject *resultobj = 0;
35613 wxWindow *arg1 = (wxWindow *) 0 ;
35614 bool result;
35615 void *argp1 = 0 ;
35616 int res1 = 0 ;
35617 PyObject *swig_obj[1] ;
35618
35619 if (!args) SWIG_fail;
35620 swig_obj[0] = args;
35621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35622 if (!SWIG_IsOK(res1)) {
35623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35624 }
35625 arg1 = reinterpret_cast< wxWindow * >(argp1);
35626 {
35627 PyThreadState* __tstate = wxPyBeginAllowThreads();
35628 result = (bool)((wxWindow const *)arg1)->IsEnabled();
35629 wxPyEndAllowThreads(__tstate);
35630 if (PyErr_Occurred()) SWIG_fail;
35631 }
35632 {
35633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35634 }
35635 return resultobj;
35636 fail:
35637 return NULL;
35638 }
35639
35640
35641 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35642 PyObject *resultobj = 0;
35643 wxWindow *arg1 = (wxWindow *) 0 ;
35644 bool result;
35645 void *argp1 = 0 ;
35646 int res1 = 0 ;
35647 PyObject *swig_obj[1] ;
35648
35649 if (!args) SWIG_fail;
35650 swig_obj[0] = args;
35651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35652 if (!SWIG_IsOK(res1)) {
35653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35654 }
35655 arg1 = reinterpret_cast< wxWindow * >(argp1);
35656 {
35657 PyThreadState* __tstate = wxPyBeginAllowThreads();
35658 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
35659 wxPyEndAllowThreads(__tstate);
35660 if (PyErr_Occurred()) SWIG_fail;
35661 }
35662 {
35663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35664 }
35665 return resultobj;
35666 fail:
35667 return NULL;
35668 }
35669
35670
35671 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35672 PyObject *resultobj = 0;
35673 wxWindow *arg1 = (wxWindow *) 0 ;
35674 long arg2 ;
35675 void *argp1 = 0 ;
35676 int res1 = 0 ;
35677 long val2 ;
35678 int ecode2 = 0 ;
35679 PyObject * obj0 = 0 ;
35680 PyObject * obj1 = 0 ;
35681 char * kwnames[] = {
35682 (char *) "self",(char *) "style", NULL
35683 };
35684
35685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35687 if (!SWIG_IsOK(res1)) {
35688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
35689 }
35690 arg1 = reinterpret_cast< wxWindow * >(argp1);
35691 ecode2 = SWIG_AsVal_long(obj1, &val2);
35692 if (!SWIG_IsOK(ecode2)) {
35693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
35694 }
35695 arg2 = static_cast< long >(val2);
35696 {
35697 PyThreadState* __tstate = wxPyBeginAllowThreads();
35698 (arg1)->SetWindowStyleFlag(arg2);
35699 wxPyEndAllowThreads(__tstate);
35700 if (PyErr_Occurred()) SWIG_fail;
35701 }
35702 resultobj = SWIG_Py_Void();
35703 return resultobj;
35704 fail:
35705 return NULL;
35706 }
35707
35708
35709 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35710 PyObject *resultobj = 0;
35711 wxWindow *arg1 = (wxWindow *) 0 ;
35712 long result;
35713 void *argp1 = 0 ;
35714 int res1 = 0 ;
35715 PyObject *swig_obj[1] ;
35716
35717 if (!args) SWIG_fail;
35718 swig_obj[0] = args;
35719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35720 if (!SWIG_IsOK(res1)) {
35721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35722 }
35723 arg1 = reinterpret_cast< wxWindow * >(argp1);
35724 {
35725 PyThreadState* __tstate = wxPyBeginAllowThreads();
35726 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
35727 wxPyEndAllowThreads(__tstate);
35728 if (PyErr_Occurred()) SWIG_fail;
35729 }
35730 resultobj = SWIG_From_long(static_cast< long >(result));
35731 return resultobj;
35732 fail:
35733 return NULL;
35734 }
35735
35736
35737 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35738 PyObject *resultobj = 0;
35739 wxWindow *arg1 = (wxWindow *) 0 ;
35740 int arg2 ;
35741 bool result;
35742 void *argp1 = 0 ;
35743 int res1 = 0 ;
35744 int val2 ;
35745 int ecode2 = 0 ;
35746 PyObject * obj0 = 0 ;
35747 PyObject * obj1 = 0 ;
35748 char * kwnames[] = {
35749 (char *) "self",(char *) "flag", NULL
35750 };
35751
35752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35754 if (!SWIG_IsOK(res1)) {
35755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35756 }
35757 arg1 = reinterpret_cast< wxWindow * >(argp1);
35758 ecode2 = SWIG_AsVal_int(obj1, &val2);
35759 if (!SWIG_IsOK(ecode2)) {
35760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
35761 }
35762 arg2 = static_cast< int >(val2);
35763 {
35764 PyThreadState* __tstate = wxPyBeginAllowThreads();
35765 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
35766 wxPyEndAllowThreads(__tstate);
35767 if (PyErr_Occurred()) SWIG_fail;
35768 }
35769 {
35770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35771 }
35772 return resultobj;
35773 fail:
35774 return NULL;
35775 }
35776
35777
35778 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35779 PyObject *resultobj = 0;
35780 wxWindow *arg1 = (wxWindow *) 0 ;
35781 bool result;
35782 void *argp1 = 0 ;
35783 int res1 = 0 ;
35784 PyObject *swig_obj[1] ;
35785
35786 if (!args) SWIG_fail;
35787 swig_obj[0] = args;
35788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35789 if (!SWIG_IsOK(res1)) {
35790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
35791 }
35792 arg1 = reinterpret_cast< wxWindow * >(argp1);
35793 {
35794 PyThreadState* __tstate = wxPyBeginAllowThreads();
35795 result = (bool)((wxWindow const *)arg1)->IsRetained();
35796 wxPyEndAllowThreads(__tstate);
35797 if (PyErr_Occurred()) SWIG_fail;
35798 }
35799 {
35800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35801 }
35802 return resultobj;
35803 fail:
35804 return NULL;
35805 }
35806
35807
35808 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35809 PyObject *resultobj = 0;
35810 wxWindow *arg1 = (wxWindow *) 0 ;
35811 long arg2 ;
35812 void *argp1 = 0 ;
35813 int res1 = 0 ;
35814 long val2 ;
35815 int ecode2 = 0 ;
35816 PyObject * obj0 = 0 ;
35817 PyObject * obj1 = 0 ;
35818 char * kwnames[] = {
35819 (char *) "self",(char *) "exStyle", NULL
35820 };
35821
35822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35824 if (!SWIG_IsOK(res1)) {
35825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35826 }
35827 arg1 = reinterpret_cast< wxWindow * >(argp1);
35828 ecode2 = SWIG_AsVal_long(obj1, &val2);
35829 if (!SWIG_IsOK(ecode2)) {
35830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
35831 }
35832 arg2 = static_cast< long >(val2);
35833 {
35834 PyThreadState* __tstate = wxPyBeginAllowThreads();
35835 (arg1)->SetExtraStyle(arg2);
35836 wxPyEndAllowThreads(__tstate);
35837 if (PyErr_Occurred()) SWIG_fail;
35838 }
35839 resultobj = SWIG_Py_Void();
35840 return resultobj;
35841 fail:
35842 return NULL;
35843 }
35844
35845
35846 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35847 PyObject *resultobj = 0;
35848 wxWindow *arg1 = (wxWindow *) 0 ;
35849 long result;
35850 void *argp1 = 0 ;
35851 int res1 = 0 ;
35852 PyObject *swig_obj[1] ;
35853
35854 if (!args) SWIG_fail;
35855 swig_obj[0] = args;
35856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35857 if (!SWIG_IsOK(res1)) {
35858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35859 }
35860 arg1 = reinterpret_cast< wxWindow * >(argp1);
35861 {
35862 PyThreadState* __tstate = wxPyBeginAllowThreads();
35863 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
35864 wxPyEndAllowThreads(__tstate);
35865 if (PyErr_Occurred()) SWIG_fail;
35866 }
35867 resultobj = SWIG_From_long(static_cast< long >(result));
35868 return resultobj;
35869 fail:
35870 return NULL;
35871 }
35872
35873
35874 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35875 PyObject *resultobj = 0;
35876 wxWindow *arg1 = (wxWindow *) 0 ;
35877 bool arg2 = (bool) true ;
35878 void *argp1 = 0 ;
35879 int res1 = 0 ;
35880 bool val2 ;
35881 int ecode2 = 0 ;
35882 PyObject * obj0 = 0 ;
35883 PyObject * obj1 = 0 ;
35884 char * kwnames[] = {
35885 (char *) "self",(char *) "modal", NULL
35886 };
35887
35888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
35889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35890 if (!SWIG_IsOK(res1)) {
35891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
35892 }
35893 arg1 = reinterpret_cast< wxWindow * >(argp1);
35894 if (obj1) {
35895 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35896 if (!SWIG_IsOK(ecode2)) {
35897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
35898 }
35899 arg2 = static_cast< bool >(val2);
35900 }
35901 {
35902 PyThreadState* __tstate = wxPyBeginAllowThreads();
35903 (arg1)->MakeModal(arg2);
35904 wxPyEndAllowThreads(__tstate);
35905 if (PyErr_Occurred()) SWIG_fail;
35906 }
35907 resultobj = SWIG_Py_Void();
35908 return resultobj;
35909 fail:
35910 return NULL;
35911 }
35912
35913
35914 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35915 PyObject *resultobj = 0;
35916 wxWindow *arg1 = (wxWindow *) 0 ;
35917 bool arg2 ;
35918 void *argp1 = 0 ;
35919 int res1 = 0 ;
35920 bool val2 ;
35921 int ecode2 = 0 ;
35922 PyObject * obj0 = 0 ;
35923 PyObject * obj1 = 0 ;
35924 char * kwnames[] = {
35925 (char *) "self",(char *) "enableTheme", NULL
35926 };
35927
35928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
35929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35930 if (!SWIG_IsOK(res1)) {
35931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
35932 }
35933 arg1 = reinterpret_cast< wxWindow * >(argp1);
35934 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35935 if (!SWIG_IsOK(ecode2)) {
35936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
35937 }
35938 arg2 = static_cast< bool >(val2);
35939 {
35940 PyThreadState* __tstate = wxPyBeginAllowThreads();
35941 (arg1)->SetThemeEnabled(arg2);
35942 wxPyEndAllowThreads(__tstate);
35943 if (PyErr_Occurred()) SWIG_fail;
35944 }
35945 resultobj = SWIG_Py_Void();
35946 return resultobj;
35947 fail:
35948 return NULL;
35949 }
35950
35951
35952 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35953 PyObject *resultobj = 0;
35954 wxWindow *arg1 = (wxWindow *) 0 ;
35955 bool result;
35956 void *argp1 = 0 ;
35957 int res1 = 0 ;
35958 PyObject *swig_obj[1] ;
35959
35960 if (!args) SWIG_fail;
35961 swig_obj[0] = args;
35962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35963 if (!SWIG_IsOK(res1)) {
35964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35965 }
35966 arg1 = reinterpret_cast< wxWindow * >(argp1);
35967 {
35968 PyThreadState* __tstate = wxPyBeginAllowThreads();
35969 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
35970 wxPyEndAllowThreads(__tstate);
35971 if (PyErr_Occurred()) SWIG_fail;
35972 }
35973 {
35974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35975 }
35976 return resultobj;
35977 fail:
35978 return NULL;
35979 }
35980
35981
35982 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35983 PyObject *resultobj = 0;
35984 wxWindow *arg1 = (wxWindow *) 0 ;
35985 void *argp1 = 0 ;
35986 int res1 = 0 ;
35987 PyObject *swig_obj[1] ;
35988
35989 if (!args) SWIG_fail;
35990 swig_obj[0] = args;
35991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35992 if (!SWIG_IsOK(res1)) {
35993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
35994 }
35995 arg1 = reinterpret_cast< wxWindow * >(argp1);
35996 {
35997 PyThreadState* __tstate = wxPyBeginAllowThreads();
35998 (arg1)->SetFocus();
35999 wxPyEndAllowThreads(__tstate);
36000 if (PyErr_Occurred()) SWIG_fail;
36001 }
36002 resultobj = SWIG_Py_Void();
36003 return resultobj;
36004 fail:
36005 return NULL;
36006 }
36007
36008
36009 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36010 PyObject *resultobj = 0;
36011 wxWindow *arg1 = (wxWindow *) 0 ;
36012 void *argp1 = 0 ;
36013 int res1 = 0 ;
36014 PyObject *swig_obj[1] ;
36015
36016 if (!args) SWIG_fail;
36017 swig_obj[0] = args;
36018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36019 if (!SWIG_IsOK(res1)) {
36020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
36021 }
36022 arg1 = reinterpret_cast< wxWindow * >(argp1);
36023 {
36024 PyThreadState* __tstate = wxPyBeginAllowThreads();
36025 (arg1)->SetFocusFromKbd();
36026 wxPyEndAllowThreads(__tstate);
36027 if (PyErr_Occurred()) SWIG_fail;
36028 }
36029 resultobj = SWIG_Py_Void();
36030 return resultobj;
36031 fail:
36032 return NULL;
36033 }
36034
36035
36036 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36037 PyObject *resultobj = 0;
36038 wxWindow *result = 0 ;
36039
36040 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
36041 {
36042 if (!wxPyCheckForApp()) SWIG_fail;
36043 PyThreadState* __tstate = wxPyBeginAllowThreads();
36044 result = (wxWindow *)wxWindow::FindFocus();
36045 wxPyEndAllowThreads(__tstate);
36046 if (PyErr_Occurred()) SWIG_fail;
36047 }
36048 {
36049 resultobj = wxPyMake_wxObject(result, 0);
36050 }
36051 return resultobj;
36052 fail:
36053 return NULL;
36054 }
36055
36056
36057 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36058 PyObject *resultobj = 0;
36059 wxWindow *arg1 = (wxWindow *) 0 ;
36060 bool result;
36061 void *argp1 = 0 ;
36062 int res1 = 0 ;
36063 PyObject *swig_obj[1] ;
36064
36065 if (!args) SWIG_fail;
36066 swig_obj[0] = args;
36067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36068 if (!SWIG_IsOK(res1)) {
36069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36070 }
36071 arg1 = reinterpret_cast< wxWindow * >(argp1);
36072 {
36073 PyThreadState* __tstate = wxPyBeginAllowThreads();
36074 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
36075 wxPyEndAllowThreads(__tstate);
36076 if (PyErr_Occurred()) SWIG_fail;
36077 }
36078 {
36079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36080 }
36081 return resultobj;
36082 fail:
36083 return NULL;
36084 }
36085
36086
36087 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36088 PyObject *resultobj = 0;
36089 wxWindow *arg1 = (wxWindow *) 0 ;
36090 bool result;
36091 void *argp1 = 0 ;
36092 int res1 = 0 ;
36093 PyObject *swig_obj[1] ;
36094
36095 if (!args) SWIG_fail;
36096 swig_obj[0] = args;
36097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36098 if (!SWIG_IsOK(res1)) {
36099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36100 }
36101 arg1 = reinterpret_cast< wxWindow * >(argp1);
36102 {
36103 PyThreadState* __tstate = wxPyBeginAllowThreads();
36104 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
36105 wxPyEndAllowThreads(__tstate);
36106 if (PyErr_Occurred()) SWIG_fail;
36107 }
36108 {
36109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36110 }
36111 return resultobj;
36112 fail:
36113 return NULL;
36114 }
36115
36116
36117 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36118 PyObject *resultobj = 0;
36119 wxWindow *arg1 = (wxWindow *) 0 ;
36120 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
36121 bool result;
36122 void *argp1 = 0 ;
36123 int res1 = 0 ;
36124 int val2 ;
36125 int ecode2 = 0 ;
36126 PyObject * obj0 = 0 ;
36127 PyObject * obj1 = 0 ;
36128 char * kwnames[] = {
36129 (char *) "self",(char *) "flags", NULL
36130 };
36131
36132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
36133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36134 if (!SWIG_IsOK(res1)) {
36135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
36136 }
36137 arg1 = reinterpret_cast< wxWindow * >(argp1);
36138 if (obj1) {
36139 ecode2 = SWIG_AsVal_int(obj1, &val2);
36140 if (!SWIG_IsOK(ecode2)) {
36141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
36142 }
36143 arg2 = static_cast< int >(val2);
36144 }
36145 {
36146 PyThreadState* __tstate = wxPyBeginAllowThreads();
36147 result = (bool)(arg1)->Navigate(arg2);
36148 wxPyEndAllowThreads(__tstate);
36149 if (PyErr_Occurred()) SWIG_fail;
36150 }
36151 {
36152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36153 }
36154 return resultobj;
36155 fail:
36156 return NULL;
36157 }
36158
36159
36160 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36161 PyObject *resultobj = 0;
36162 wxWindow *arg1 = (wxWindow *) 0 ;
36163 wxWindow *arg2 = (wxWindow *) 0 ;
36164 void *argp1 = 0 ;
36165 int res1 = 0 ;
36166 void *argp2 = 0 ;
36167 int res2 = 0 ;
36168 PyObject * obj0 = 0 ;
36169 PyObject * obj1 = 0 ;
36170 char * kwnames[] = {
36171 (char *) "self",(char *) "win", NULL
36172 };
36173
36174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36176 if (!SWIG_IsOK(res1)) {
36177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36178 }
36179 arg1 = reinterpret_cast< wxWindow * >(argp1);
36180 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36181 if (!SWIG_IsOK(res2)) {
36182 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36183 }
36184 arg2 = reinterpret_cast< wxWindow * >(argp2);
36185 {
36186 PyThreadState* __tstate = wxPyBeginAllowThreads();
36187 (arg1)->MoveAfterInTabOrder(arg2);
36188 wxPyEndAllowThreads(__tstate);
36189 if (PyErr_Occurred()) SWIG_fail;
36190 }
36191 resultobj = SWIG_Py_Void();
36192 return resultobj;
36193 fail:
36194 return NULL;
36195 }
36196
36197
36198 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36199 PyObject *resultobj = 0;
36200 wxWindow *arg1 = (wxWindow *) 0 ;
36201 wxWindow *arg2 = (wxWindow *) 0 ;
36202 void *argp1 = 0 ;
36203 int res1 = 0 ;
36204 void *argp2 = 0 ;
36205 int res2 = 0 ;
36206 PyObject * obj0 = 0 ;
36207 PyObject * obj1 = 0 ;
36208 char * kwnames[] = {
36209 (char *) "self",(char *) "win", NULL
36210 };
36211
36212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36214 if (!SWIG_IsOK(res1)) {
36215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36216 }
36217 arg1 = reinterpret_cast< wxWindow * >(argp1);
36218 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36219 if (!SWIG_IsOK(res2)) {
36220 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36221 }
36222 arg2 = reinterpret_cast< wxWindow * >(argp2);
36223 {
36224 PyThreadState* __tstate = wxPyBeginAllowThreads();
36225 (arg1)->MoveBeforeInTabOrder(arg2);
36226 wxPyEndAllowThreads(__tstate);
36227 if (PyErr_Occurred()) SWIG_fail;
36228 }
36229 resultobj = SWIG_Py_Void();
36230 return resultobj;
36231 fail:
36232 return NULL;
36233 }
36234
36235
36236 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36237 PyObject *resultobj = 0;
36238 wxWindow *arg1 = (wxWindow *) 0 ;
36239 PyObject *result = 0 ;
36240 void *argp1 = 0 ;
36241 int res1 = 0 ;
36242 PyObject *swig_obj[1] ;
36243
36244 if (!args) SWIG_fail;
36245 swig_obj[0] = args;
36246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36247 if (!SWIG_IsOK(res1)) {
36248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
36249 }
36250 arg1 = reinterpret_cast< wxWindow * >(argp1);
36251 {
36252 PyThreadState* __tstate = wxPyBeginAllowThreads();
36253 result = (PyObject *)wxWindow_GetChildren(arg1);
36254 wxPyEndAllowThreads(__tstate);
36255 if (PyErr_Occurred()) SWIG_fail;
36256 }
36257 resultobj = result;
36258 return resultobj;
36259 fail:
36260 return NULL;
36261 }
36262
36263
36264 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36265 PyObject *resultobj = 0;
36266 wxWindow *arg1 = (wxWindow *) 0 ;
36267 wxWindow *result = 0 ;
36268 void *argp1 = 0 ;
36269 int res1 = 0 ;
36270 PyObject *swig_obj[1] ;
36271
36272 if (!args) SWIG_fail;
36273 swig_obj[0] = args;
36274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36275 if (!SWIG_IsOK(res1)) {
36276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36277 }
36278 arg1 = reinterpret_cast< wxWindow * >(argp1);
36279 {
36280 PyThreadState* __tstate = wxPyBeginAllowThreads();
36281 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
36282 wxPyEndAllowThreads(__tstate);
36283 if (PyErr_Occurred()) SWIG_fail;
36284 }
36285 {
36286 resultobj = wxPyMake_wxObject(result, 0);
36287 }
36288 return resultobj;
36289 fail:
36290 return NULL;
36291 }
36292
36293
36294 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36295 PyObject *resultobj = 0;
36296 wxWindow *arg1 = (wxWindow *) 0 ;
36297 wxWindow *result = 0 ;
36298 void *argp1 = 0 ;
36299 int res1 = 0 ;
36300 PyObject *swig_obj[1] ;
36301
36302 if (!args) SWIG_fail;
36303 swig_obj[0] = args;
36304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36305 if (!SWIG_IsOK(res1)) {
36306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36307 }
36308 arg1 = reinterpret_cast< wxWindow * >(argp1);
36309 {
36310 PyThreadState* __tstate = wxPyBeginAllowThreads();
36311 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
36312 wxPyEndAllowThreads(__tstate);
36313 if (PyErr_Occurred()) SWIG_fail;
36314 }
36315 {
36316 resultobj = wxPyMake_wxObject(result, 0);
36317 }
36318 return resultobj;
36319 fail:
36320 return NULL;
36321 }
36322
36323
36324 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36325 PyObject *resultobj = 0;
36326 wxWindow *arg1 = (wxWindow *) 0 ;
36327 bool result;
36328 void *argp1 = 0 ;
36329 int res1 = 0 ;
36330 PyObject *swig_obj[1] ;
36331
36332 if (!args) SWIG_fail;
36333 swig_obj[0] = args;
36334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36335 if (!SWIG_IsOK(res1)) {
36336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
36337 }
36338 arg1 = reinterpret_cast< wxWindow * >(argp1);
36339 {
36340 PyThreadState* __tstate = wxPyBeginAllowThreads();
36341 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
36342 wxPyEndAllowThreads(__tstate);
36343 if (PyErr_Occurred()) SWIG_fail;
36344 }
36345 {
36346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36347 }
36348 return resultobj;
36349 fail:
36350 return NULL;
36351 }
36352
36353
36354 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36355 PyObject *resultobj = 0;
36356 wxWindow *arg1 = (wxWindow *) 0 ;
36357 wxWindow *arg2 = (wxWindow *) 0 ;
36358 bool result;
36359 void *argp1 = 0 ;
36360 int res1 = 0 ;
36361 void *argp2 = 0 ;
36362 int res2 = 0 ;
36363 PyObject * obj0 = 0 ;
36364 PyObject * obj1 = 0 ;
36365 char * kwnames[] = {
36366 (char *) "self",(char *) "newParent", NULL
36367 };
36368
36369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
36370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36371 if (!SWIG_IsOK(res1)) {
36372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
36373 }
36374 arg1 = reinterpret_cast< wxWindow * >(argp1);
36375 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36376 if (!SWIG_IsOK(res2)) {
36377 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
36378 }
36379 arg2 = reinterpret_cast< wxWindow * >(argp2);
36380 {
36381 PyThreadState* __tstate = wxPyBeginAllowThreads();
36382 result = (bool)(arg1)->Reparent(arg2);
36383 wxPyEndAllowThreads(__tstate);
36384 if (PyErr_Occurred()) SWIG_fail;
36385 }
36386 {
36387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36388 }
36389 return resultobj;
36390 fail:
36391 return NULL;
36392 }
36393
36394
36395 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36396 PyObject *resultobj = 0;
36397 wxWindow *arg1 = (wxWindow *) 0 ;
36398 wxWindow *arg2 = (wxWindow *) 0 ;
36399 void *argp1 = 0 ;
36400 int res1 = 0 ;
36401 void *argp2 = 0 ;
36402 int res2 = 0 ;
36403 PyObject * obj0 = 0 ;
36404 PyObject * obj1 = 0 ;
36405 char * kwnames[] = {
36406 (char *) "self",(char *) "child", NULL
36407 };
36408
36409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
36410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36411 if (!SWIG_IsOK(res1)) {
36412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36413 }
36414 arg1 = reinterpret_cast< wxWindow * >(argp1);
36415 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36416 if (!SWIG_IsOK(res2)) {
36417 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36418 }
36419 arg2 = reinterpret_cast< wxWindow * >(argp2);
36420 {
36421 PyThreadState* __tstate = wxPyBeginAllowThreads();
36422 (arg1)->AddChild(arg2);
36423 wxPyEndAllowThreads(__tstate);
36424 if (PyErr_Occurred()) SWIG_fail;
36425 }
36426 resultobj = SWIG_Py_Void();
36427 return resultobj;
36428 fail:
36429 return NULL;
36430 }
36431
36432
36433 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36434 PyObject *resultobj = 0;
36435 wxWindow *arg1 = (wxWindow *) 0 ;
36436 wxWindow *arg2 = (wxWindow *) 0 ;
36437 void *argp1 = 0 ;
36438 int res1 = 0 ;
36439 void *argp2 = 0 ;
36440 int res2 = 0 ;
36441 PyObject * obj0 = 0 ;
36442 PyObject * obj1 = 0 ;
36443 char * kwnames[] = {
36444 (char *) "self",(char *) "child", NULL
36445 };
36446
36447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
36448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36449 if (!SWIG_IsOK(res1)) {
36450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36451 }
36452 arg1 = reinterpret_cast< wxWindow * >(argp1);
36453 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36454 if (!SWIG_IsOK(res2)) {
36455 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36456 }
36457 arg2 = reinterpret_cast< wxWindow * >(argp2);
36458 {
36459 PyThreadState* __tstate = wxPyBeginAllowThreads();
36460 (arg1)->RemoveChild(arg2);
36461 wxPyEndAllowThreads(__tstate);
36462 if (PyErr_Occurred()) SWIG_fail;
36463 }
36464 resultobj = SWIG_Py_Void();
36465 return resultobj;
36466 fail:
36467 return NULL;
36468 }
36469
36470
36471 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36472 PyObject *resultobj = 0;
36473 wxWindow *arg1 = (wxWindow *) 0 ;
36474 bool arg2 ;
36475 void *argp1 = 0 ;
36476 int res1 = 0 ;
36477 bool val2 ;
36478 int ecode2 = 0 ;
36479 PyObject * obj0 = 0 ;
36480 PyObject * obj1 = 0 ;
36481 char * kwnames[] = {
36482 (char *) "self",(char *) "on", NULL
36483 };
36484
36485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
36486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36487 if (!SWIG_IsOK(res1)) {
36488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
36489 }
36490 arg1 = reinterpret_cast< wxWindow * >(argp1);
36491 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36492 if (!SWIG_IsOK(ecode2)) {
36493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
36494 }
36495 arg2 = static_cast< bool >(val2);
36496 {
36497 PyThreadState* __tstate = wxPyBeginAllowThreads();
36498 (arg1)->SetDoubleBuffered(arg2);
36499 wxPyEndAllowThreads(__tstate);
36500 if (PyErr_Occurred()) SWIG_fail;
36501 }
36502 resultobj = SWIG_Py_Void();
36503 return resultobj;
36504 fail:
36505 return NULL;
36506 }
36507
36508
36509 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36510 PyObject *resultobj = 0;
36511 wxWindow *arg1 = (wxWindow *) 0 ;
36512 long arg2 ;
36513 wxWindow *result = 0 ;
36514 void *argp1 = 0 ;
36515 int res1 = 0 ;
36516 long val2 ;
36517 int ecode2 = 0 ;
36518 PyObject * obj0 = 0 ;
36519 PyObject * obj1 = 0 ;
36520 char * kwnames[] = {
36521 (char *) "self",(char *) "winid", NULL
36522 };
36523
36524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",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_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
36528 }
36529 arg1 = reinterpret_cast< wxWindow * >(argp1);
36530 ecode2 = SWIG_AsVal_long(obj1, &val2);
36531 if (!SWIG_IsOK(ecode2)) {
36532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
36533 }
36534 arg2 = static_cast< long >(val2);
36535 {
36536 PyThreadState* __tstate = wxPyBeginAllowThreads();
36537 result = (wxWindow *)(arg1)->FindWindow(arg2);
36538 wxPyEndAllowThreads(__tstate);
36539 if (PyErr_Occurred()) SWIG_fail;
36540 }
36541 {
36542 resultobj = wxPyMake_wxObject(result, 0);
36543 }
36544 return resultobj;
36545 fail:
36546 return NULL;
36547 }
36548
36549
36550 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36551 PyObject *resultobj = 0;
36552 wxWindow *arg1 = (wxWindow *) 0 ;
36553 wxString *arg2 = 0 ;
36554 wxWindow *result = 0 ;
36555 void *argp1 = 0 ;
36556 int res1 = 0 ;
36557 bool temp2 = false ;
36558 PyObject * obj0 = 0 ;
36559 PyObject * obj1 = 0 ;
36560 char * kwnames[] = {
36561 (char *) "self",(char *) "name", NULL
36562 };
36563
36564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
36565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36566 if (!SWIG_IsOK(res1)) {
36567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
36568 }
36569 arg1 = reinterpret_cast< wxWindow * >(argp1);
36570 {
36571 arg2 = wxString_in_helper(obj1);
36572 if (arg2 == NULL) SWIG_fail;
36573 temp2 = true;
36574 }
36575 {
36576 PyThreadState* __tstate = wxPyBeginAllowThreads();
36577 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
36578 wxPyEndAllowThreads(__tstate);
36579 if (PyErr_Occurred()) SWIG_fail;
36580 }
36581 {
36582 resultobj = wxPyMake_wxObject(result, 0);
36583 }
36584 {
36585 if (temp2)
36586 delete arg2;
36587 }
36588 return resultobj;
36589 fail:
36590 {
36591 if (temp2)
36592 delete arg2;
36593 }
36594 return NULL;
36595 }
36596
36597
36598 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36599 PyObject *resultobj = 0;
36600 wxWindow *arg1 = (wxWindow *) 0 ;
36601 wxEvtHandler *result = 0 ;
36602 void *argp1 = 0 ;
36603 int res1 = 0 ;
36604 PyObject *swig_obj[1] ;
36605
36606 if (!args) SWIG_fail;
36607 swig_obj[0] = args;
36608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36609 if (!SWIG_IsOK(res1)) {
36610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
36611 }
36612 arg1 = reinterpret_cast< wxWindow * >(argp1);
36613 {
36614 PyThreadState* __tstate = wxPyBeginAllowThreads();
36615 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
36616 wxPyEndAllowThreads(__tstate);
36617 if (PyErr_Occurred()) SWIG_fail;
36618 }
36619 {
36620 resultobj = wxPyMake_wxObject(result, 0);
36621 }
36622 return resultobj;
36623 fail:
36624 return NULL;
36625 }
36626
36627
36628 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36629 PyObject *resultobj = 0;
36630 wxWindow *arg1 = (wxWindow *) 0 ;
36631 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36632 void *argp1 = 0 ;
36633 int res1 = 0 ;
36634 void *argp2 = 0 ;
36635 int res2 = 0 ;
36636 PyObject * obj0 = 0 ;
36637 PyObject * obj1 = 0 ;
36638 char * kwnames[] = {
36639 (char *) "self",(char *) "handler", NULL
36640 };
36641
36642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36644 if (!SWIG_IsOK(res1)) {
36645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36646 }
36647 arg1 = reinterpret_cast< wxWindow * >(argp1);
36648 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36649 if (!SWIG_IsOK(res2)) {
36650 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36651 }
36652 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36653 {
36654 PyThreadState* __tstate = wxPyBeginAllowThreads();
36655 (arg1)->SetEventHandler(arg2);
36656 wxPyEndAllowThreads(__tstate);
36657 if (PyErr_Occurred()) SWIG_fail;
36658 }
36659 resultobj = SWIG_Py_Void();
36660 return resultobj;
36661 fail:
36662 return NULL;
36663 }
36664
36665
36666 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36667 PyObject *resultobj = 0;
36668 wxWindow *arg1 = (wxWindow *) 0 ;
36669 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36670 void *argp1 = 0 ;
36671 int res1 = 0 ;
36672 void *argp2 = 0 ;
36673 int res2 = 0 ;
36674 PyObject * obj0 = 0 ;
36675 PyObject * obj1 = 0 ;
36676 char * kwnames[] = {
36677 (char *) "self",(char *) "handler", NULL
36678 };
36679
36680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36682 if (!SWIG_IsOK(res1)) {
36683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36684 }
36685 arg1 = reinterpret_cast< wxWindow * >(argp1);
36686 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36687 if (!SWIG_IsOK(res2)) {
36688 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36689 }
36690 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36691 {
36692 PyThreadState* __tstate = wxPyBeginAllowThreads();
36693 (arg1)->PushEventHandler(arg2);
36694 wxPyEndAllowThreads(__tstate);
36695 if (PyErr_Occurred()) SWIG_fail;
36696 }
36697 resultobj = SWIG_Py_Void();
36698 return resultobj;
36699 fail:
36700 return NULL;
36701 }
36702
36703
36704 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36705 PyObject *resultobj = 0;
36706 wxWindow *arg1 = (wxWindow *) 0 ;
36707 bool arg2 = (bool) false ;
36708 wxEvtHandler *result = 0 ;
36709 void *argp1 = 0 ;
36710 int res1 = 0 ;
36711 bool val2 ;
36712 int ecode2 = 0 ;
36713 PyObject * obj0 = 0 ;
36714 PyObject * obj1 = 0 ;
36715 char * kwnames[] = {
36716 (char *) "self",(char *) "deleteHandler", NULL
36717 };
36718
36719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36721 if (!SWIG_IsOK(res1)) {
36722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36723 }
36724 arg1 = reinterpret_cast< wxWindow * >(argp1);
36725 if (obj1) {
36726 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36727 if (!SWIG_IsOK(ecode2)) {
36728 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
36729 }
36730 arg2 = static_cast< bool >(val2);
36731 }
36732 {
36733 PyThreadState* __tstate = wxPyBeginAllowThreads();
36734 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
36735 wxPyEndAllowThreads(__tstate);
36736 if (PyErr_Occurred()) SWIG_fail;
36737 }
36738 {
36739 resultobj = wxPyMake_wxObject(result, 0);
36740 }
36741 return resultobj;
36742 fail:
36743 return NULL;
36744 }
36745
36746
36747 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36748 PyObject *resultobj = 0;
36749 wxWindow *arg1 = (wxWindow *) 0 ;
36750 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36751 bool result;
36752 void *argp1 = 0 ;
36753 int res1 = 0 ;
36754 void *argp2 = 0 ;
36755 int res2 = 0 ;
36756 PyObject * obj0 = 0 ;
36757 PyObject * obj1 = 0 ;
36758 char * kwnames[] = {
36759 (char *) "self",(char *) "handler", NULL
36760 };
36761
36762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36764 if (!SWIG_IsOK(res1)) {
36765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36766 }
36767 arg1 = reinterpret_cast< wxWindow * >(argp1);
36768 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36769 if (!SWIG_IsOK(res2)) {
36770 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36771 }
36772 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36773 {
36774 PyThreadState* __tstate = wxPyBeginAllowThreads();
36775 result = (bool)(arg1)->RemoveEventHandler(arg2);
36776 wxPyEndAllowThreads(__tstate);
36777 if (PyErr_Occurred()) SWIG_fail;
36778 }
36779 {
36780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36781 }
36782 return resultobj;
36783 fail:
36784 return NULL;
36785 }
36786
36787
36788 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36789 PyObject *resultobj = 0;
36790 wxWindow *arg1 = (wxWindow *) 0 ;
36791 wxValidator *arg2 = 0 ;
36792 void *argp1 = 0 ;
36793 int res1 = 0 ;
36794 void *argp2 = 0 ;
36795 int res2 = 0 ;
36796 PyObject * obj0 = 0 ;
36797 PyObject * obj1 = 0 ;
36798 char * kwnames[] = {
36799 (char *) "self",(char *) "validator", NULL
36800 };
36801
36802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
36803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36804 if (!SWIG_IsOK(res1)) {
36805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
36806 }
36807 arg1 = reinterpret_cast< wxWindow * >(argp1);
36808 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
36809 if (!SWIG_IsOK(res2)) {
36810 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
36811 }
36812 if (!argp2) {
36813 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
36814 }
36815 arg2 = reinterpret_cast< wxValidator * >(argp2);
36816 {
36817 PyThreadState* __tstate = wxPyBeginAllowThreads();
36818 (arg1)->SetValidator((wxValidator const &)*arg2);
36819 wxPyEndAllowThreads(__tstate);
36820 if (PyErr_Occurred()) SWIG_fail;
36821 }
36822 resultobj = SWIG_Py_Void();
36823 return resultobj;
36824 fail:
36825 return NULL;
36826 }
36827
36828
36829 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36830 PyObject *resultobj = 0;
36831 wxWindow *arg1 = (wxWindow *) 0 ;
36832 wxValidator *result = 0 ;
36833 void *argp1 = 0 ;
36834 int res1 = 0 ;
36835 PyObject *swig_obj[1] ;
36836
36837 if (!args) SWIG_fail;
36838 swig_obj[0] = args;
36839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36840 if (!SWIG_IsOK(res1)) {
36841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
36842 }
36843 arg1 = reinterpret_cast< wxWindow * >(argp1);
36844 {
36845 PyThreadState* __tstate = wxPyBeginAllowThreads();
36846 result = (wxValidator *)(arg1)->GetValidator();
36847 wxPyEndAllowThreads(__tstate);
36848 if (PyErr_Occurred()) SWIG_fail;
36849 }
36850 {
36851 resultobj = wxPyMake_wxObject(result, (bool)0);
36852 }
36853 return resultobj;
36854 fail:
36855 return NULL;
36856 }
36857
36858
36859 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36860 PyObject *resultobj = 0;
36861 wxWindow *arg1 = (wxWindow *) 0 ;
36862 bool result;
36863 void *argp1 = 0 ;
36864 int res1 = 0 ;
36865 PyObject *swig_obj[1] ;
36866
36867 if (!args) SWIG_fail;
36868 swig_obj[0] = args;
36869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36870 if (!SWIG_IsOK(res1)) {
36871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
36872 }
36873 arg1 = reinterpret_cast< wxWindow * >(argp1);
36874 {
36875 PyThreadState* __tstate = wxPyBeginAllowThreads();
36876 result = (bool)(arg1)->Validate();
36877 wxPyEndAllowThreads(__tstate);
36878 if (PyErr_Occurred()) SWIG_fail;
36879 }
36880 {
36881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36882 }
36883 return resultobj;
36884 fail:
36885 return NULL;
36886 }
36887
36888
36889 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36890 PyObject *resultobj = 0;
36891 wxWindow *arg1 = (wxWindow *) 0 ;
36892 bool result;
36893 void *argp1 = 0 ;
36894 int res1 = 0 ;
36895 PyObject *swig_obj[1] ;
36896
36897 if (!args) SWIG_fail;
36898 swig_obj[0] = args;
36899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36900 if (!SWIG_IsOK(res1)) {
36901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36902 }
36903 arg1 = reinterpret_cast< wxWindow * >(argp1);
36904 {
36905 PyThreadState* __tstate = wxPyBeginAllowThreads();
36906 result = (bool)(arg1)->TransferDataToWindow();
36907 wxPyEndAllowThreads(__tstate);
36908 if (PyErr_Occurred()) SWIG_fail;
36909 }
36910 {
36911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36912 }
36913 return resultobj;
36914 fail:
36915 return NULL;
36916 }
36917
36918
36919 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36920 PyObject *resultobj = 0;
36921 wxWindow *arg1 = (wxWindow *) 0 ;
36922 bool result;
36923 void *argp1 = 0 ;
36924 int res1 = 0 ;
36925 PyObject *swig_obj[1] ;
36926
36927 if (!args) SWIG_fail;
36928 swig_obj[0] = args;
36929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36930 if (!SWIG_IsOK(res1)) {
36931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36932 }
36933 arg1 = reinterpret_cast< wxWindow * >(argp1);
36934 {
36935 PyThreadState* __tstate = wxPyBeginAllowThreads();
36936 result = (bool)(arg1)->TransferDataFromWindow();
36937 wxPyEndAllowThreads(__tstate);
36938 if (PyErr_Occurred()) SWIG_fail;
36939 }
36940 {
36941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36942 }
36943 return resultobj;
36944 fail:
36945 return NULL;
36946 }
36947
36948
36949 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36950 PyObject *resultobj = 0;
36951 wxWindow *arg1 = (wxWindow *) 0 ;
36952 void *argp1 = 0 ;
36953 int res1 = 0 ;
36954 PyObject *swig_obj[1] ;
36955
36956 if (!args) SWIG_fail;
36957 swig_obj[0] = args;
36958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36959 if (!SWIG_IsOK(res1)) {
36960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
36961 }
36962 arg1 = reinterpret_cast< wxWindow * >(argp1);
36963 {
36964 PyThreadState* __tstate = wxPyBeginAllowThreads();
36965 (arg1)->InitDialog();
36966 wxPyEndAllowThreads(__tstate);
36967 if (PyErr_Occurred()) SWIG_fail;
36968 }
36969 resultobj = SWIG_Py_Void();
36970 return resultobj;
36971 fail:
36972 return NULL;
36973 }
36974
36975
36976 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36977 PyObject *resultobj = 0;
36978 wxWindow *arg1 = (wxWindow *) 0 ;
36979 wxAcceleratorTable *arg2 = 0 ;
36980 void *argp1 = 0 ;
36981 int res1 = 0 ;
36982 void *argp2 = 0 ;
36983 int res2 = 0 ;
36984 PyObject * obj0 = 0 ;
36985 PyObject * obj1 = 0 ;
36986 char * kwnames[] = {
36987 (char *) "self",(char *) "accel", NULL
36988 };
36989
36990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
36991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36992 if (!SWIG_IsOK(res1)) {
36993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
36994 }
36995 arg1 = reinterpret_cast< wxWindow * >(argp1);
36996 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
36997 if (!SWIG_IsOK(res2)) {
36998 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
36999 }
37000 if (!argp2) {
37001 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37002 }
37003 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
37004 {
37005 PyThreadState* __tstate = wxPyBeginAllowThreads();
37006 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
37007 wxPyEndAllowThreads(__tstate);
37008 if (PyErr_Occurred()) SWIG_fail;
37009 }
37010 resultobj = SWIG_Py_Void();
37011 return resultobj;
37012 fail:
37013 return NULL;
37014 }
37015
37016
37017 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37018 PyObject *resultobj = 0;
37019 wxWindow *arg1 = (wxWindow *) 0 ;
37020 wxAcceleratorTable *result = 0 ;
37021 void *argp1 = 0 ;
37022 int res1 = 0 ;
37023 PyObject *swig_obj[1] ;
37024
37025 if (!args) SWIG_fail;
37026 swig_obj[0] = args;
37027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37028 if (!SWIG_IsOK(res1)) {
37029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37030 }
37031 arg1 = reinterpret_cast< wxWindow * >(argp1);
37032 {
37033 PyThreadState* __tstate = wxPyBeginAllowThreads();
37034 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
37035 wxPyEndAllowThreads(__tstate);
37036 if (PyErr_Occurred()) SWIG_fail;
37037 }
37038 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
37039 return resultobj;
37040 fail:
37041 return NULL;
37042 }
37043
37044
37045 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37046 PyObject *resultobj = 0;
37047 wxWindow *arg1 = (wxWindow *) 0 ;
37048 int arg2 ;
37049 int arg3 ;
37050 int arg4 ;
37051 bool result;
37052 void *argp1 = 0 ;
37053 int res1 = 0 ;
37054 int val2 ;
37055 int ecode2 = 0 ;
37056 int val3 ;
37057 int ecode3 = 0 ;
37058 int val4 ;
37059 int ecode4 = 0 ;
37060 PyObject * obj0 = 0 ;
37061 PyObject * obj1 = 0 ;
37062 PyObject * obj2 = 0 ;
37063 PyObject * obj3 = 0 ;
37064 char * kwnames[] = {
37065 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
37066 };
37067
37068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37070 if (!SWIG_IsOK(res1)) {
37071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37072 }
37073 arg1 = reinterpret_cast< wxWindow * >(argp1);
37074 ecode2 = SWIG_AsVal_int(obj1, &val2);
37075 if (!SWIG_IsOK(ecode2)) {
37076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
37077 }
37078 arg2 = static_cast< int >(val2);
37079 ecode3 = SWIG_AsVal_int(obj2, &val3);
37080 if (!SWIG_IsOK(ecode3)) {
37081 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
37082 }
37083 arg3 = static_cast< int >(val3);
37084 ecode4 = SWIG_AsVal_int(obj3, &val4);
37085 if (!SWIG_IsOK(ecode4)) {
37086 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
37087 }
37088 arg4 = static_cast< int >(val4);
37089 {
37090 PyThreadState* __tstate = wxPyBeginAllowThreads();
37091 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
37092 wxPyEndAllowThreads(__tstate);
37093 if (PyErr_Occurred()) SWIG_fail;
37094 }
37095 {
37096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37097 }
37098 return resultobj;
37099 fail:
37100 return NULL;
37101 }
37102
37103
37104 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37105 PyObject *resultobj = 0;
37106 wxWindow *arg1 = (wxWindow *) 0 ;
37107 int arg2 ;
37108 bool result;
37109 void *argp1 = 0 ;
37110 int res1 = 0 ;
37111 int val2 ;
37112 int ecode2 = 0 ;
37113 PyObject * obj0 = 0 ;
37114 PyObject * obj1 = 0 ;
37115 char * kwnames[] = {
37116 (char *) "self",(char *) "hotkeyId", NULL
37117 };
37118
37119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
37120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37121 if (!SWIG_IsOK(res1)) {
37122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37123 }
37124 arg1 = reinterpret_cast< wxWindow * >(argp1);
37125 ecode2 = SWIG_AsVal_int(obj1, &val2);
37126 if (!SWIG_IsOK(ecode2)) {
37127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
37128 }
37129 arg2 = static_cast< int >(val2);
37130 {
37131 PyThreadState* __tstate = wxPyBeginAllowThreads();
37132 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
37133 wxPyEndAllowThreads(__tstate);
37134 if (PyErr_Occurred()) SWIG_fail;
37135 }
37136 {
37137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37138 }
37139 return resultobj;
37140 fail:
37141 return NULL;
37142 }
37143
37144
37145 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37146 PyObject *resultobj = 0;
37147 wxWindow *arg1 = (wxWindow *) 0 ;
37148 wxPoint *arg2 = 0 ;
37149 wxPoint result;
37150 void *argp1 = 0 ;
37151 int res1 = 0 ;
37152 wxPoint temp2 ;
37153 PyObject * obj0 = 0 ;
37154 PyObject * obj1 = 0 ;
37155 char * kwnames[] = {
37156 (char *) "self",(char *) "pt", NULL
37157 };
37158
37159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37161 if (!SWIG_IsOK(res1)) {
37162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37163 }
37164 arg1 = reinterpret_cast< wxWindow * >(argp1);
37165 {
37166 arg2 = &temp2;
37167 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37168 }
37169 {
37170 PyThreadState* __tstate = wxPyBeginAllowThreads();
37171 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37172 wxPyEndAllowThreads(__tstate);
37173 if (PyErr_Occurred()) SWIG_fail;
37174 }
37175 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37176 return resultobj;
37177 fail:
37178 return NULL;
37179 }
37180
37181
37182 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37183 PyObject *resultobj = 0;
37184 wxWindow *arg1 = (wxWindow *) 0 ;
37185 wxSize *arg2 = 0 ;
37186 wxSize result;
37187 void *argp1 = 0 ;
37188 int res1 = 0 ;
37189 wxSize temp2 ;
37190 PyObject * obj0 = 0 ;
37191 PyObject * obj1 = 0 ;
37192 char * kwnames[] = {
37193 (char *) "self",(char *) "sz", NULL
37194 };
37195
37196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37198 if (!SWIG_IsOK(res1)) {
37199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37200 }
37201 arg1 = reinterpret_cast< wxWindow * >(argp1);
37202 {
37203 arg2 = &temp2;
37204 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37205 }
37206 {
37207 PyThreadState* __tstate = wxPyBeginAllowThreads();
37208 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37209 wxPyEndAllowThreads(__tstate);
37210 if (PyErr_Occurred()) SWIG_fail;
37211 }
37212 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37213 return resultobj;
37214 fail:
37215 return NULL;
37216 }
37217
37218
37219 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37220 PyObject *resultobj = 0;
37221 wxWindow *arg1 = (wxWindow *) 0 ;
37222 wxPoint *arg2 = 0 ;
37223 wxPoint result;
37224 void *argp1 = 0 ;
37225 int res1 = 0 ;
37226 wxPoint temp2 ;
37227 PyObject * obj0 = 0 ;
37228 PyObject * obj1 = 0 ;
37229 char * kwnames[] = {
37230 (char *) "self",(char *) "pt", NULL
37231 };
37232
37233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
37234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37235 if (!SWIG_IsOK(res1)) {
37236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
37237 }
37238 arg1 = reinterpret_cast< wxWindow * >(argp1);
37239 {
37240 arg2 = &temp2;
37241 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37242 }
37243 {
37244 PyThreadState* __tstate = wxPyBeginAllowThreads();
37245 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37246 wxPyEndAllowThreads(__tstate);
37247 if (PyErr_Occurred()) SWIG_fail;
37248 }
37249 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37250 return resultobj;
37251 fail:
37252 return NULL;
37253 }
37254
37255
37256 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37257 PyObject *resultobj = 0;
37258 wxWindow *arg1 = (wxWindow *) 0 ;
37259 wxSize *arg2 = 0 ;
37260 wxSize result;
37261 void *argp1 = 0 ;
37262 int res1 = 0 ;
37263 wxSize temp2 ;
37264 PyObject * obj0 = 0 ;
37265 PyObject * obj1 = 0 ;
37266 char * kwnames[] = {
37267 (char *) "self",(char *) "sz", NULL
37268 };
37269
37270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
37271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37272 if (!SWIG_IsOK(res1)) {
37273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
37274 }
37275 arg1 = reinterpret_cast< wxWindow * >(argp1);
37276 {
37277 arg2 = &temp2;
37278 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37279 }
37280 {
37281 PyThreadState* __tstate = wxPyBeginAllowThreads();
37282 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37283 wxPyEndAllowThreads(__tstate);
37284 if (PyErr_Occurred()) SWIG_fail;
37285 }
37286 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37287 return resultobj;
37288 fail:
37289 return NULL;
37290 }
37291
37292
37293 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37294 PyObject *resultobj = 0;
37295 wxWindow *arg1 = (wxWindow *) 0 ;
37296 wxPoint *arg2 = 0 ;
37297 wxPoint result;
37298 void *argp1 = 0 ;
37299 int res1 = 0 ;
37300 wxPoint temp2 ;
37301 PyObject * obj0 = 0 ;
37302 PyObject * obj1 = 0 ;
37303 char * kwnames[] = {
37304 (char *) "self",(char *) "pt", NULL
37305 };
37306
37307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37309 if (!SWIG_IsOK(res1)) {
37310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37311 }
37312 arg1 = reinterpret_cast< wxWindow * >(argp1);
37313 {
37314 arg2 = &temp2;
37315 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37316 }
37317 {
37318 PyThreadState* __tstate = wxPyBeginAllowThreads();
37319 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
37320 wxPyEndAllowThreads(__tstate);
37321 if (PyErr_Occurred()) SWIG_fail;
37322 }
37323 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37324 return resultobj;
37325 fail:
37326 return NULL;
37327 }
37328
37329
37330 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37331 PyObject *resultobj = 0;
37332 wxWindow *arg1 = (wxWindow *) 0 ;
37333 wxSize *arg2 = 0 ;
37334 wxSize result;
37335 void *argp1 = 0 ;
37336 int res1 = 0 ;
37337 wxSize temp2 ;
37338 PyObject * obj0 = 0 ;
37339 PyObject * obj1 = 0 ;
37340 char * kwnames[] = {
37341 (char *) "self",(char *) "sz", NULL
37342 };
37343
37344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37346 if (!SWIG_IsOK(res1)) {
37347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37348 }
37349 arg1 = reinterpret_cast< wxWindow * >(argp1);
37350 {
37351 arg2 = &temp2;
37352 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37353 }
37354 {
37355 PyThreadState* __tstate = wxPyBeginAllowThreads();
37356 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
37357 wxPyEndAllowThreads(__tstate);
37358 if (PyErr_Occurred()) SWIG_fail;
37359 }
37360 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37361 return resultobj;
37362 fail:
37363 return NULL;
37364 }
37365
37366
37367 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37368 PyObject *resultobj = 0;
37369 wxWindow *arg1 = (wxWindow *) 0 ;
37370 int arg2 ;
37371 int arg3 ;
37372 void *argp1 = 0 ;
37373 int res1 = 0 ;
37374 int val2 ;
37375 int ecode2 = 0 ;
37376 int val3 ;
37377 int ecode3 = 0 ;
37378 PyObject * obj0 = 0 ;
37379 PyObject * obj1 = 0 ;
37380 PyObject * obj2 = 0 ;
37381 char * kwnames[] = {
37382 (char *) "self",(char *) "x",(char *) "y", NULL
37383 };
37384
37385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37387 if (!SWIG_IsOK(res1)) {
37388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
37389 }
37390 arg1 = reinterpret_cast< wxWindow * >(argp1);
37391 ecode2 = SWIG_AsVal_int(obj1, &val2);
37392 if (!SWIG_IsOK(ecode2)) {
37393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
37394 }
37395 arg2 = static_cast< int >(val2);
37396 ecode3 = SWIG_AsVal_int(obj2, &val3);
37397 if (!SWIG_IsOK(ecode3)) {
37398 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
37399 }
37400 arg3 = static_cast< int >(val3);
37401 {
37402 PyThreadState* __tstate = wxPyBeginAllowThreads();
37403 (arg1)->WarpPointer(arg2,arg3);
37404 wxPyEndAllowThreads(__tstate);
37405 if (PyErr_Occurred()) SWIG_fail;
37406 }
37407 resultobj = SWIG_Py_Void();
37408 return resultobj;
37409 fail:
37410 return NULL;
37411 }
37412
37413
37414 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37415 PyObject *resultobj = 0;
37416 wxWindow *arg1 = (wxWindow *) 0 ;
37417 void *argp1 = 0 ;
37418 int res1 = 0 ;
37419 PyObject *swig_obj[1] ;
37420
37421 if (!args) SWIG_fail;
37422 swig_obj[0] = args;
37423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37424 if (!SWIG_IsOK(res1)) {
37425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37426 }
37427 arg1 = reinterpret_cast< wxWindow * >(argp1);
37428 {
37429 PyThreadState* __tstate = wxPyBeginAllowThreads();
37430 (arg1)->CaptureMouse();
37431 wxPyEndAllowThreads(__tstate);
37432 if (PyErr_Occurred()) SWIG_fail;
37433 }
37434 resultobj = SWIG_Py_Void();
37435 return resultobj;
37436 fail:
37437 return NULL;
37438 }
37439
37440
37441 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37442 PyObject *resultobj = 0;
37443 wxWindow *arg1 = (wxWindow *) 0 ;
37444 void *argp1 = 0 ;
37445 int res1 = 0 ;
37446 PyObject *swig_obj[1] ;
37447
37448 if (!args) SWIG_fail;
37449 swig_obj[0] = args;
37450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37451 if (!SWIG_IsOK(res1)) {
37452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37453 }
37454 arg1 = reinterpret_cast< wxWindow * >(argp1);
37455 {
37456 PyThreadState* __tstate = wxPyBeginAllowThreads();
37457 (arg1)->ReleaseMouse();
37458 wxPyEndAllowThreads(__tstate);
37459 if (PyErr_Occurred()) SWIG_fail;
37460 }
37461 resultobj = SWIG_Py_Void();
37462 return resultobj;
37463 fail:
37464 return NULL;
37465 }
37466
37467
37468 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37469 PyObject *resultobj = 0;
37470 wxWindow *result = 0 ;
37471
37472 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
37473 {
37474 if (!wxPyCheckForApp()) SWIG_fail;
37475 PyThreadState* __tstate = wxPyBeginAllowThreads();
37476 result = (wxWindow *)wxWindow::GetCapture();
37477 wxPyEndAllowThreads(__tstate);
37478 if (PyErr_Occurred()) SWIG_fail;
37479 }
37480 {
37481 resultobj = wxPyMake_wxObject(result, 0);
37482 }
37483 return resultobj;
37484 fail:
37485 return NULL;
37486 }
37487
37488
37489 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37490 PyObject *resultobj = 0;
37491 wxWindow *arg1 = (wxWindow *) 0 ;
37492 bool result;
37493 void *argp1 = 0 ;
37494 int res1 = 0 ;
37495 PyObject *swig_obj[1] ;
37496
37497 if (!args) SWIG_fail;
37498 swig_obj[0] = args;
37499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37500 if (!SWIG_IsOK(res1)) {
37501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
37502 }
37503 arg1 = reinterpret_cast< wxWindow * >(argp1);
37504 {
37505 PyThreadState* __tstate = wxPyBeginAllowThreads();
37506 result = (bool)((wxWindow const *)arg1)->HasCapture();
37507 wxPyEndAllowThreads(__tstate);
37508 if (PyErr_Occurred()) SWIG_fail;
37509 }
37510 {
37511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37512 }
37513 return resultobj;
37514 fail:
37515 return NULL;
37516 }
37517
37518
37519 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37520 PyObject *resultobj = 0;
37521 wxWindow *arg1 = (wxWindow *) 0 ;
37522 bool arg2 = (bool) true ;
37523 wxRect *arg3 = (wxRect *) NULL ;
37524 void *argp1 = 0 ;
37525 int res1 = 0 ;
37526 bool val2 ;
37527 int ecode2 = 0 ;
37528 void *argp3 = 0 ;
37529 int res3 = 0 ;
37530 PyObject * obj0 = 0 ;
37531 PyObject * obj1 = 0 ;
37532 PyObject * obj2 = 0 ;
37533 char * kwnames[] = {
37534 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
37535 };
37536
37537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37539 if (!SWIG_IsOK(res1)) {
37540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
37541 }
37542 arg1 = reinterpret_cast< wxWindow * >(argp1);
37543 if (obj1) {
37544 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37545 if (!SWIG_IsOK(ecode2)) {
37546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
37547 }
37548 arg2 = static_cast< bool >(val2);
37549 }
37550 if (obj2) {
37551 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
37552 if (!SWIG_IsOK(res3)) {
37553 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
37554 }
37555 arg3 = reinterpret_cast< wxRect * >(argp3);
37556 }
37557 {
37558 PyThreadState* __tstate = wxPyBeginAllowThreads();
37559 (arg1)->Refresh(arg2,(wxRect const *)arg3);
37560 wxPyEndAllowThreads(__tstate);
37561 if (PyErr_Occurred()) SWIG_fail;
37562 }
37563 resultobj = SWIG_Py_Void();
37564 return resultobj;
37565 fail:
37566 return NULL;
37567 }
37568
37569
37570 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37571 PyObject *resultobj = 0;
37572 wxWindow *arg1 = (wxWindow *) 0 ;
37573 wxRect *arg2 = 0 ;
37574 bool arg3 = (bool) true ;
37575 void *argp1 = 0 ;
37576 int res1 = 0 ;
37577 wxRect temp2 ;
37578 bool val3 ;
37579 int ecode3 = 0 ;
37580 PyObject * obj0 = 0 ;
37581 PyObject * obj1 = 0 ;
37582 PyObject * obj2 = 0 ;
37583 char * kwnames[] = {
37584 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
37585 };
37586
37587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37589 if (!SWIG_IsOK(res1)) {
37590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
37591 }
37592 arg1 = reinterpret_cast< wxWindow * >(argp1);
37593 {
37594 arg2 = &temp2;
37595 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
37596 }
37597 if (obj2) {
37598 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37599 if (!SWIG_IsOK(ecode3)) {
37600 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
37601 }
37602 arg3 = static_cast< bool >(val3);
37603 }
37604 {
37605 PyThreadState* __tstate = wxPyBeginAllowThreads();
37606 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
37607 wxPyEndAllowThreads(__tstate);
37608 if (PyErr_Occurred()) SWIG_fail;
37609 }
37610 resultobj = SWIG_Py_Void();
37611 return resultobj;
37612 fail:
37613 return NULL;
37614 }
37615
37616
37617 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37618 PyObject *resultobj = 0;
37619 wxWindow *arg1 = (wxWindow *) 0 ;
37620 void *argp1 = 0 ;
37621 int res1 = 0 ;
37622 PyObject *swig_obj[1] ;
37623
37624 if (!args) SWIG_fail;
37625 swig_obj[0] = args;
37626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37627 if (!SWIG_IsOK(res1)) {
37628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
37629 }
37630 arg1 = reinterpret_cast< wxWindow * >(argp1);
37631 {
37632 PyThreadState* __tstate = wxPyBeginAllowThreads();
37633 (arg1)->Update();
37634 wxPyEndAllowThreads(__tstate);
37635 if (PyErr_Occurred()) SWIG_fail;
37636 }
37637 resultobj = SWIG_Py_Void();
37638 return resultobj;
37639 fail:
37640 return NULL;
37641 }
37642
37643
37644 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37645 PyObject *resultobj = 0;
37646 wxWindow *arg1 = (wxWindow *) 0 ;
37647 void *argp1 = 0 ;
37648 int res1 = 0 ;
37649 PyObject *swig_obj[1] ;
37650
37651 if (!args) SWIG_fail;
37652 swig_obj[0] = args;
37653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37654 if (!SWIG_IsOK(res1)) {
37655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
37656 }
37657 arg1 = reinterpret_cast< wxWindow * >(argp1);
37658 {
37659 PyThreadState* __tstate = wxPyBeginAllowThreads();
37660 (arg1)->ClearBackground();
37661 wxPyEndAllowThreads(__tstate);
37662 if (PyErr_Occurred()) SWIG_fail;
37663 }
37664 resultobj = SWIG_Py_Void();
37665 return resultobj;
37666 fail:
37667 return NULL;
37668 }
37669
37670
37671 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37672 PyObject *resultobj = 0;
37673 wxWindow *arg1 = (wxWindow *) 0 ;
37674 void *argp1 = 0 ;
37675 int res1 = 0 ;
37676 PyObject *swig_obj[1] ;
37677
37678 if (!args) SWIG_fail;
37679 swig_obj[0] = args;
37680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37681 if (!SWIG_IsOK(res1)) {
37682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
37683 }
37684 arg1 = reinterpret_cast< wxWindow * >(argp1);
37685 {
37686 PyThreadState* __tstate = wxPyBeginAllowThreads();
37687 (arg1)->Freeze();
37688 wxPyEndAllowThreads(__tstate);
37689 if (PyErr_Occurred()) SWIG_fail;
37690 }
37691 resultobj = SWIG_Py_Void();
37692 return resultobj;
37693 fail:
37694 return NULL;
37695 }
37696
37697
37698 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37699 PyObject *resultobj = 0;
37700 wxWindow *arg1 = (wxWindow *) 0 ;
37701 bool result;
37702 void *argp1 = 0 ;
37703 int res1 = 0 ;
37704 PyObject *swig_obj[1] ;
37705
37706 if (!args) SWIG_fail;
37707 swig_obj[0] = args;
37708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37709 if (!SWIG_IsOK(res1)) {
37710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
37711 }
37712 arg1 = reinterpret_cast< wxWindow * >(argp1);
37713 {
37714 PyThreadState* __tstate = wxPyBeginAllowThreads();
37715 result = (bool)((wxWindow const *)arg1)->IsFrozen();
37716 wxPyEndAllowThreads(__tstate);
37717 if (PyErr_Occurred()) SWIG_fail;
37718 }
37719 {
37720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37721 }
37722 return resultobj;
37723 fail:
37724 return NULL;
37725 }
37726
37727
37728 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37729 PyObject *resultobj = 0;
37730 wxWindow *arg1 = (wxWindow *) 0 ;
37731 void *argp1 = 0 ;
37732 int res1 = 0 ;
37733 PyObject *swig_obj[1] ;
37734
37735 if (!args) SWIG_fail;
37736 swig_obj[0] = args;
37737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37738 if (!SWIG_IsOK(res1)) {
37739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
37740 }
37741 arg1 = reinterpret_cast< wxWindow * >(argp1);
37742 {
37743 PyThreadState* __tstate = wxPyBeginAllowThreads();
37744 (arg1)->Thaw();
37745 wxPyEndAllowThreads(__tstate);
37746 if (PyErr_Occurred()) SWIG_fail;
37747 }
37748 resultobj = SWIG_Py_Void();
37749 return resultobj;
37750 fail:
37751 return NULL;
37752 }
37753
37754
37755 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37756 PyObject *resultobj = 0;
37757 wxWindow *arg1 = (wxWindow *) 0 ;
37758 wxDC *arg2 = 0 ;
37759 void *argp1 = 0 ;
37760 int res1 = 0 ;
37761 void *argp2 = 0 ;
37762 int res2 = 0 ;
37763 PyObject * obj0 = 0 ;
37764 PyObject * obj1 = 0 ;
37765 char * kwnames[] = {
37766 (char *) "self",(char *) "dc", NULL
37767 };
37768
37769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
37770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37771 if (!SWIG_IsOK(res1)) {
37772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
37773 }
37774 arg1 = reinterpret_cast< wxWindow * >(argp1);
37775 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
37776 if (!SWIG_IsOK(res2)) {
37777 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
37778 }
37779 if (!argp2) {
37780 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
37781 }
37782 arg2 = reinterpret_cast< wxDC * >(argp2);
37783 {
37784 PyThreadState* __tstate = wxPyBeginAllowThreads();
37785 (arg1)->PrepareDC(*arg2);
37786 wxPyEndAllowThreads(__tstate);
37787 if (PyErr_Occurred()) SWIG_fail;
37788 }
37789 resultobj = SWIG_Py_Void();
37790 return resultobj;
37791 fail:
37792 return NULL;
37793 }
37794
37795
37796 SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37797 PyObject *resultobj = 0;
37798 wxWindow *arg1 = (wxWindow *) 0 ;
37799 bool result;
37800 void *argp1 = 0 ;
37801 int res1 = 0 ;
37802 PyObject *swig_obj[1] ;
37803
37804 if (!args) SWIG_fail;
37805 swig_obj[0] = args;
37806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37807 if (!SWIG_IsOK(res1)) {
37808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
37809 }
37810 arg1 = reinterpret_cast< wxWindow * >(argp1);
37811 {
37812 PyThreadState* __tstate = wxPyBeginAllowThreads();
37813 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
37814 wxPyEndAllowThreads(__tstate);
37815 if (PyErr_Occurred()) SWIG_fail;
37816 }
37817 {
37818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37819 }
37820 return resultobj;
37821 fail:
37822 return NULL;
37823 }
37824
37825
37826 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37827 PyObject *resultobj = 0;
37828 wxWindow *arg1 = (wxWindow *) 0 ;
37829 wxRegion *result = 0 ;
37830 void *argp1 = 0 ;
37831 int res1 = 0 ;
37832 PyObject *swig_obj[1] ;
37833
37834 if (!args) SWIG_fail;
37835 swig_obj[0] = args;
37836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37837 if (!SWIG_IsOK(res1)) {
37838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
37839 }
37840 arg1 = reinterpret_cast< wxWindow * >(argp1);
37841 {
37842 PyThreadState* __tstate = wxPyBeginAllowThreads();
37843 {
37844 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
37845 result = (wxRegion *) &_result_ref;
37846 }
37847 wxPyEndAllowThreads(__tstate);
37848 if (PyErr_Occurred()) SWIG_fail;
37849 }
37850 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
37851 return resultobj;
37852 fail:
37853 return NULL;
37854 }
37855
37856
37857 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37858 PyObject *resultobj = 0;
37859 wxWindow *arg1 = (wxWindow *) 0 ;
37860 wxRect result;
37861 void *argp1 = 0 ;
37862 int res1 = 0 ;
37863 PyObject *swig_obj[1] ;
37864
37865 if (!args) SWIG_fail;
37866 swig_obj[0] = args;
37867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37868 if (!SWIG_IsOK(res1)) {
37869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
37870 }
37871 arg1 = reinterpret_cast< wxWindow * >(argp1);
37872 {
37873 PyThreadState* __tstate = wxPyBeginAllowThreads();
37874 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
37875 wxPyEndAllowThreads(__tstate);
37876 if (PyErr_Occurred()) SWIG_fail;
37877 }
37878 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
37879 return resultobj;
37880 fail:
37881 return NULL;
37882 }
37883
37884
37885 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37886 PyObject *resultobj = 0;
37887 wxWindow *arg1 = (wxWindow *) 0 ;
37888 int arg2 ;
37889 int arg3 ;
37890 int arg4 = (int) 1 ;
37891 int arg5 = (int) 1 ;
37892 bool result;
37893 void *argp1 = 0 ;
37894 int res1 = 0 ;
37895 int val2 ;
37896 int ecode2 = 0 ;
37897 int val3 ;
37898 int ecode3 = 0 ;
37899 int val4 ;
37900 int ecode4 = 0 ;
37901 int val5 ;
37902 int ecode5 = 0 ;
37903 PyObject * obj0 = 0 ;
37904 PyObject * obj1 = 0 ;
37905 PyObject * obj2 = 0 ;
37906 PyObject * obj3 = 0 ;
37907 PyObject * obj4 = 0 ;
37908 char * kwnames[] = {
37909 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
37910 };
37911
37912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
37913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37914 if (!SWIG_IsOK(res1)) {
37915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
37916 }
37917 arg1 = reinterpret_cast< wxWindow * >(argp1);
37918 ecode2 = SWIG_AsVal_int(obj1, &val2);
37919 if (!SWIG_IsOK(ecode2)) {
37920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
37921 }
37922 arg2 = static_cast< int >(val2);
37923 ecode3 = SWIG_AsVal_int(obj2, &val3);
37924 if (!SWIG_IsOK(ecode3)) {
37925 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
37926 }
37927 arg3 = static_cast< int >(val3);
37928 if (obj3) {
37929 ecode4 = SWIG_AsVal_int(obj3, &val4);
37930 if (!SWIG_IsOK(ecode4)) {
37931 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
37932 }
37933 arg4 = static_cast< int >(val4);
37934 }
37935 if (obj4) {
37936 ecode5 = SWIG_AsVal_int(obj4, &val5);
37937 if (!SWIG_IsOK(ecode5)) {
37938 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
37939 }
37940 arg5 = static_cast< int >(val5);
37941 }
37942 {
37943 PyThreadState* __tstate = wxPyBeginAllowThreads();
37944 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
37945 wxPyEndAllowThreads(__tstate);
37946 if (PyErr_Occurred()) SWIG_fail;
37947 }
37948 {
37949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37950 }
37951 return resultobj;
37952 fail:
37953 return NULL;
37954 }
37955
37956
37957 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37958 PyObject *resultobj = 0;
37959 wxWindow *arg1 = (wxWindow *) 0 ;
37960 wxPoint *arg2 = 0 ;
37961 bool result;
37962 void *argp1 = 0 ;
37963 int res1 = 0 ;
37964 wxPoint temp2 ;
37965 PyObject * obj0 = 0 ;
37966 PyObject * obj1 = 0 ;
37967 char * kwnames[] = {
37968 (char *) "self",(char *) "pt", NULL
37969 };
37970
37971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
37972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37973 if (!SWIG_IsOK(res1)) {
37974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
37975 }
37976 arg1 = reinterpret_cast< wxWindow * >(argp1);
37977 {
37978 arg2 = &temp2;
37979 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37980 }
37981 {
37982 PyThreadState* __tstate = wxPyBeginAllowThreads();
37983 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
37984 wxPyEndAllowThreads(__tstate);
37985 if (PyErr_Occurred()) SWIG_fail;
37986 }
37987 {
37988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37989 }
37990 return resultobj;
37991 fail:
37992 return NULL;
37993 }
37994
37995
37996 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37997 PyObject *resultobj = 0;
37998 wxWindow *arg1 = (wxWindow *) 0 ;
37999 wxRect *arg2 = 0 ;
38000 bool result;
38001 void *argp1 = 0 ;
38002 int res1 = 0 ;
38003 wxRect temp2 ;
38004 PyObject * obj0 = 0 ;
38005 PyObject * obj1 = 0 ;
38006 char * kwnames[] = {
38007 (char *) "self",(char *) "rect", NULL
38008 };
38009
38010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
38011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38012 if (!SWIG_IsOK(res1)) {
38013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38014 }
38015 arg1 = reinterpret_cast< wxWindow * >(argp1);
38016 {
38017 arg2 = &temp2;
38018 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38019 }
38020 {
38021 PyThreadState* __tstate = wxPyBeginAllowThreads();
38022 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
38023 wxPyEndAllowThreads(__tstate);
38024 if (PyErr_Occurred()) SWIG_fail;
38025 }
38026 {
38027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38028 }
38029 return resultobj;
38030 fail:
38031 return NULL;
38032 }
38033
38034
38035 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38036 PyObject *resultobj = 0;
38037 wxWindow *arg1 = (wxWindow *) 0 ;
38038 SwigValueWrapper<wxVisualAttributes > result;
38039 void *argp1 = 0 ;
38040 int res1 = 0 ;
38041 PyObject *swig_obj[1] ;
38042
38043 if (!args) SWIG_fail;
38044 swig_obj[0] = args;
38045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38046 if (!SWIG_IsOK(res1)) {
38047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
38048 }
38049 arg1 = reinterpret_cast< wxWindow * >(argp1);
38050 {
38051 PyThreadState* __tstate = wxPyBeginAllowThreads();
38052 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
38053 wxPyEndAllowThreads(__tstate);
38054 if (PyErr_Occurred()) SWIG_fail;
38055 }
38056 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38057 return resultobj;
38058 fail:
38059 return NULL;
38060 }
38061
38062
38063 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38064 PyObject *resultobj = 0;
38065 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38066 SwigValueWrapper<wxVisualAttributes > result;
38067 int val1 ;
38068 int ecode1 = 0 ;
38069 PyObject * obj0 = 0 ;
38070 char * kwnames[] = {
38071 (char *) "variant", NULL
38072 };
38073
38074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
38075 if (obj0) {
38076 ecode1 = SWIG_AsVal_int(obj0, &val1);
38077 if (!SWIG_IsOK(ecode1)) {
38078 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
38079 }
38080 arg1 = static_cast< wxWindowVariant >(val1);
38081 }
38082 {
38083 if (!wxPyCheckForApp()) SWIG_fail;
38084 PyThreadState* __tstate = wxPyBeginAllowThreads();
38085 result = wxWindow::GetClassDefaultAttributes(arg1);
38086 wxPyEndAllowThreads(__tstate);
38087 if (PyErr_Occurred()) SWIG_fail;
38088 }
38089 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38090 return resultobj;
38091 fail:
38092 return NULL;
38093 }
38094
38095
38096 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38097 PyObject *resultobj = 0;
38098 wxWindow *arg1 = (wxWindow *) 0 ;
38099 wxColour *arg2 = 0 ;
38100 bool result;
38101 void *argp1 = 0 ;
38102 int res1 = 0 ;
38103 wxColour temp2 ;
38104 PyObject * obj0 = 0 ;
38105 PyObject * obj1 = 0 ;
38106 char * kwnames[] = {
38107 (char *) "self",(char *) "colour", NULL
38108 };
38109
38110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38112 if (!SWIG_IsOK(res1)) {
38113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38114 }
38115 arg1 = reinterpret_cast< wxWindow * >(argp1);
38116 {
38117 arg2 = &temp2;
38118 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38119 }
38120 {
38121 PyThreadState* __tstate = wxPyBeginAllowThreads();
38122 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
38123 wxPyEndAllowThreads(__tstate);
38124 if (PyErr_Occurred()) SWIG_fail;
38125 }
38126 {
38127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38128 }
38129 return resultobj;
38130 fail:
38131 return NULL;
38132 }
38133
38134
38135 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38136 PyObject *resultobj = 0;
38137 wxWindow *arg1 = (wxWindow *) 0 ;
38138 wxColour *arg2 = 0 ;
38139 void *argp1 = 0 ;
38140 int res1 = 0 ;
38141 wxColour temp2 ;
38142 PyObject * obj0 = 0 ;
38143 PyObject * obj1 = 0 ;
38144 char * kwnames[] = {
38145 (char *) "self",(char *) "colour", NULL
38146 };
38147
38148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38150 if (!SWIG_IsOK(res1)) {
38151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38152 }
38153 arg1 = reinterpret_cast< wxWindow * >(argp1);
38154 {
38155 arg2 = &temp2;
38156 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38157 }
38158 {
38159 PyThreadState* __tstate = wxPyBeginAllowThreads();
38160 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
38161 wxPyEndAllowThreads(__tstate);
38162 if (PyErr_Occurred()) SWIG_fail;
38163 }
38164 resultobj = SWIG_Py_Void();
38165 return resultobj;
38166 fail:
38167 return NULL;
38168 }
38169
38170
38171 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38172 PyObject *resultobj = 0;
38173 wxWindow *arg1 = (wxWindow *) 0 ;
38174 wxColour *arg2 = 0 ;
38175 bool result;
38176 void *argp1 = 0 ;
38177 int res1 = 0 ;
38178 wxColour temp2 ;
38179 PyObject * obj0 = 0 ;
38180 PyObject * obj1 = 0 ;
38181 char * kwnames[] = {
38182 (char *) "self",(char *) "colour", NULL
38183 };
38184
38185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38187 if (!SWIG_IsOK(res1)) {
38188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38189 }
38190 arg1 = reinterpret_cast< wxWindow * >(argp1);
38191 {
38192 arg2 = &temp2;
38193 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38194 }
38195 {
38196 PyThreadState* __tstate = wxPyBeginAllowThreads();
38197 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
38198 wxPyEndAllowThreads(__tstate);
38199 if (PyErr_Occurred()) SWIG_fail;
38200 }
38201 {
38202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38203 }
38204 return resultobj;
38205 fail:
38206 return NULL;
38207 }
38208
38209
38210 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38211 PyObject *resultobj = 0;
38212 wxWindow *arg1 = (wxWindow *) 0 ;
38213 wxColour *arg2 = 0 ;
38214 void *argp1 = 0 ;
38215 int res1 = 0 ;
38216 wxColour temp2 ;
38217 PyObject * obj0 = 0 ;
38218 PyObject * obj1 = 0 ;
38219 char * kwnames[] = {
38220 (char *) "self",(char *) "colour", NULL
38221 };
38222
38223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38225 if (!SWIG_IsOK(res1)) {
38226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38227 }
38228 arg1 = reinterpret_cast< wxWindow * >(argp1);
38229 {
38230 arg2 = &temp2;
38231 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38232 }
38233 {
38234 PyThreadState* __tstate = wxPyBeginAllowThreads();
38235 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
38236 wxPyEndAllowThreads(__tstate);
38237 if (PyErr_Occurred()) SWIG_fail;
38238 }
38239 resultobj = SWIG_Py_Void();
38240 return resultobj;
38241 fail:
38242 return NULL;
38243 }
38244
38245
38246 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38247 PyObject *resultobj = 0;
38248 wxWindow *arg1 = (wxWindow *) 0 ;
38249 wxColour result;
38250 void *argp1 = 0 ;
38251 int res1 = 0 ;
38252 PyObject *swig_obj[1] ;
38253
38254 if (!args) SWIG_fail;
38255 swig_obj[0] = args;
38256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38257 if (!SWIG_IsOK(res1)) {
38258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38259 }
38260 arg1 = reinterpret_cast< wxWindow * >(argp1);
38261 {
38262 PyThreadState* __tstate = wxPyBeginAllowThreads();
38263 result = ((wxWindow const *)arg1)->GetBackgroundColour();
38264 wxPyEndAllowThreads(__tstate);
38265 if (PyErr_Occurred()) SWIG_fail;
38266 }
38267 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38268 return resultobj;
38269 fail:
38270 return NULL;
38271 }
38272
38273
38274 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38275 PyObject *resultobj = 0;
38276 wxWindow *arg1 = (wxWindow *) 0 ;
38277 wxColour result;
38278 void *argp1 = 0 ;
38279 int res1 = 0 ;
38280 PyObject *swig_obj[1] ;
38281
38282 if (!args) SWIG_fail;
38283 swig_obj[0] = args;
38284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38285 if (!SWIG_IsOK(res1)) {
38286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38287 }
38288 arg1 = reinterpret_cast< wxWindow * >(argp1);
38289 {
38290 PyThreadState* __tstate = wxPyBeginAllowThreads();
38291 result = ((wxWindow const *)arg1)->GetForegroundColour();
38292 wxPyEndAllowThreads(__tstate);
38293 if (PyErr_Occurred()) SWIG_fail;
38294 }
38295 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38296 return resultobj;
38297 fail:
38298 return NULL;
38299 }
38300
38301
38302 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38303 PyObject *resultobj = 0;
38304 wxWindow *arg1 = (wxWindow *) 0 ;
38305 bool result;
38306 void *argp1 = 0 ;
38307 int res1 = 0 ;
38308 PyObject *swig_obj[1] ;
38309
38310 if (!args) SWIG_fail;
38311 swig_obj[0] = args;
38312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38313 if (!SWIG_IsOK(res1)) {
38314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38315 }
38316 arg1 = reinterpret_cast< wxWindow * >(argp1);
38317 {
38318 PyThreadState* __tstate = wxPyBeginAllowThreads();
38319 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
38320 wxPyEndAllowThreads(__tstate);
38321 if (PyErr_Occurred()) SWIG_fail;
38322 }
38323 {
38324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38325 }
38326 return resultobj;
38327 fail:
38328 return NULL;
38329 }
38330
38331
38332 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38333 PyObject *resultobj = 0;
38334 wxWindow *arg1 = (wxWindow *) 0 ;
38335 bool result;
38336 void *argp1 = 0 ;
38337 int res1 = 0 ;
38338 PyObject *swig_obj[1] ;
38339
38340 if (!args) SWIG_fail;
38341 swig_obj[0] = args;
38342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38343 if (!SWIG_IsOK(res1)) {
38344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
38345 }
38346 arg1 = reinterpret_cast< wxWindow * >(argp1);
38347 {
38348 PyThreadState* __tstate = wxPyBeginAllowThreads();
38349 result = (bool)((wxWindow const *)arg1)->UseBgCol();
38350 wxPyEndAllowThreads(__tstate);
38351 if (PyErr_Occurred()) SWIG_fail;
38352 }
38353 {
38354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38355 }
38356 return resultobj;
38357 fail:
38358 return NULL;
38359 }
38360
38361
38362 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38363 PyObject *resultobj = 0;
38364 wxWindow *arg1 = (wxWindow *) 0 ;
38365 wxBackgroundStyle arg2 ;
38366 bool result;
38367 void *argp1 = 0 ;
38368 int res1 = 0 ;
38369 int val2 ;
38370 int ecode2 = 0 ;
38371 PyObject * obj0 = 0 ;
38372 PyObject * obj1 = 0 ;
38373 char * kwnames[] = {
38374 (char *) "self",(char *) "style", NULL
38375 };
38376
38377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
38378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38379 if (!SWIG_IsOK(res1)) {
38380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
38381 }
38382 arg1 = reinterpret_cast< wxWindow * >(argp1);
38383 ecode2 = SWIG_AsVal_int(obj1, &val2);
38384 if (!SWIG_IsOK(ecode2)) {
38385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
38386 }
38387 arg2 = static_cast< wxBackgroundStyle >(val2);
38388 {
38389 PyThreadState* __tstate = wxPyBeginAllowThreads();
38390 result = (bool)(arg1)->SetBackgroundStyle(arg2);
38391 wxPyEndAllowThreads(__tstate);
38392 if (PyErr_Occurred()) SWIG_fail;
38393 }
38394 {
38395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38396 }
38397 return resultobj;
38398 fail:
38399 return NULL;
38400 }
38401
38402
38403 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38404 PyObject *resultobj = 0;
38405 wxWindow *arg1 = (wxWindow *) 0 ;
38406 wxBackgroundStyle result;
38407 void *argp1 = 0 ;
38408 int res1 = 0 ;
38409 PyObject *swig_obj[1] ;
38410
38411 if (!args) SWIG_fail;
38412 swig_obj[0] = args;
38413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38414 if (!SWIG_IsOK(res1)) {
38415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
38416 }
38417 arg1 = reinterpret_cast< wxWindow * >(argp1);
38418 {
38419 PyThreadState* __tstate = wxPyBeginAllowThreads();
38420 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
38421 wxPyEndAllowThreads(__tstate);
38422 if (PyErr_Occurred()) SWIG_fail;
38423 }
38424 resultobj = SWIG_From_int(static_cast< int >(result));
38425 return resultobj;
38426 fail:
38427 return NULL;
38428 }
38429
38430
38431 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38432 PyObject *resultobj = 0;
38433 wxWindow *arg1 = (wxWindow *) 0 ;
38434 bool result;
38435 void *argp1 = 0 ;
38436 int res1 = 0 ;
38437 PyObject *swig_obj[1] ;
38438
38439 if (!args) SWIG_fail;
38440 swig_obj[0] = args;
38441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38442 if (!SWIG_IsOK(res1)) {
38443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
38444 }
38445 arg1 = reinterpret_cast< wxWindow * >(argp1);
38446 {
38447 PyThreadState* __tstate = wxPyBeginAllowThreads();
38448 result = (bool)(arg1)->HasTransparentBackground();
38449 wxPyEndAllowThreads(__tstate);
38450 if (PyErr_Occurred()) SWIG_fail;
38451 }
38452 {
38453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38454 }
38455 return resultobj;
38456 fail:
38457 return NULL;
38458 }
38459
38460
38461 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38462 PyObject *resultobj = 0;
38463 wxWindow *arg1 = (wxWindow *) 0 ;
38464 wxCursor *arg2 = 0 ;
38465 bool result;
38466 void *argp1 = 0 ;
38467 int res1 = 0 ;
38468 void *argp2 = 0 ;
38469 int res2 = 0 ;
38470 PyObject * obj0 = 0 ;
38471 PyObject * obj1 = 0 ;
38472 char * kwnames[] = {
38473 (char *) "self",(char *) "cursor", NULL
38474 };
38475
38476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
38477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38478 if (!SWIG_IsOK(res1)) {
38479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38480 }
38481 arg1 = reinterpret_cast< wxWindow * >(argp1);
38482 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
38483 if (!SWIG_IsOK(res2)) {
38484 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38485 }
38486 if (!argp2) {
38487 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38488 }
38489 arg2 = reinterpret_cast< wxCursor * >(argp2);
38490 {
38491 PyThreadState* __tstate = wxPyBeginAllowThreads();
38492 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
38493 wxPyEndAllowThreads(__tstate);
38494 if (PyErr_Occurred()) SWIG_fail;
38495 }
38496 {
38497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38498 }
38499 return resultobj;
38500 fail:
38501 return NULL;
38502 }
38503
38504
38505 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38506 PyObject *resultobj = 0;
38507 wxWindow *arg1 = (wxWindow *) 0 ;
38508 wxCursor result;
38509 void *argp1 = 0 ;
38510 int res1 = 0 ;
38511 PyObject *swig_obj[1] ;
38512
38513 if (!args) SWIG_fail;
38514 swig_obj[0] = args;
38515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38516 if (!SWIG_IsOK(res1)) {
38517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38518 }
38519 arg1 = reinterpret_cast< wxWindow * >(argp1);
38520 {
38521 PyThreadState* __tstate = wxPyBeginAllowThreads();
38522 result = (arg1)->GetCursor();
38523 wxPyEndAllowThreads(__tstate);
38524 if (PyErr_Occurred()) SWIG_fail;
38525 }
38526 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
38527 return resultobj;
38528 fail:
38529 return NULL;
38530 }
38531
38532
38533 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38534 PyObject *resultobj = 0;
38535 wxWindow *arg1 = (wxWindow *) 0 ;
38536 wxFont *arg2 = 0 ;
38537 bool result;
38538 void *argp1 = 0 ;
38539 int res1 = 0 ;
38540 void *argp2 = 0 ;
38541 int res2 = 0 ;
38542 PyObject * obj0 = 0 ;
38543 PyObject * obj1 = 0 ;
38544 char * kwnames[] = {
38545 (char *) "self",(char *) "font", NULL
38546 };
38547
38548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
38549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38550 if (!SWIG_IsOK(res1)) {
38551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38552 }
38553 arg1 = reinterpret_cast< wxWindow * >(argp1);
38554 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38555 if (!SWIG_IsOK(res2)) {
38556 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38557 }
38558 if (!argp2) {
38559 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38560 }
38561 arg2 = reinterpret_cast< wxFont * >(argp2);
38562 {
38563 PyThreadState* __tstate = wxPyBeginAllowThreads();
38564 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
38565 wxPyEndAllowThreads(__tstate);
38566 if (PyErr_Occurred()) SWIG_fail;
38567 }
38568 {
38569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38570 }
38571 return resultobj;
38572 fail:
38573 return NULL;
38574 }
38575
38576
38577 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38578 PyObject *resultobj = 0;
38579 wxWindow *arg1 = (wxWindow *) 0 ;
38580 wxFont *arg2 = 0 ;
38581 void *argp1 = 0 ;
38582 int res1 = 0 ;
38583 void *argp2 = 0 ;
38584 int res2 = 0 ;
38585 PyObject * obj0 = 0 ;
38586 PyObject * obj1 = 0 ;
38587 char * kwnames[] = {
38588 (char *) "self",(char *) "font", NULL
38589 };
38590
38591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
38592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38593 if (!SWIG_IsOK(res1)) {
38594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38595 }
38596 arg1 = reinterpret_cast< wxWindow * >(argp1);
38597 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38598 if (!SWIG_IsOK(res2)) {
38599 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38600 }
38601 if (!argp2) {
38602 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38603 }
38604 arg2 = reinterpret_cast< wxFont * >(argp2);
38605 {
38606 PyThreadState* __tstate = wxPyBeginAllowThreads();
38607 (arg1)->SetOwnFont((wxFont const &)*arg2);
38608 wxPyEndAllowThreads(__tstate);
38609 if (PyErr_Occurred()) SWIG_fail;
38610 }
38611 resultobj = SWIG_Py_Void();
38612 return resultobj;
38613 fail:
38614 return NULL;
38615 }
38616
38617
38618 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38619 PyObject *resultobj = 0;
38620 wxWindow *arg1 = (wxWindow *) 0 ;
38621 wxFont result;
38622 void *argp1 = 0 ;
38623 int res1 = 0 ;
38624 PyObject *swig_obj[1] ;
38625
38626 if (!args) SWIG_fail;
38627 swig_obj[0] = args;
38628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38629 if (!SWIG_IsOK(res1)) {
38630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38631 }
38632 arg1 = reinterpret_cast< wxWindow * >(argp1);
38633 {
38634 PyThreadState* __tstate = wxPyBeginAllowThreads();
38635 result = (arg1)->GetFont();
38636 wxPyEndAllowThreads(__tstate);
38637 if (PyErr_Occurred()) SWIG_fail;
38638 }
38639 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
38640 return resultobj;
38641 fail:
38642 return NULL;
38643 }
38644
38645
38646 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38647 PyObject *resultobj = 0;
38648 wxWindow *arg1 = (wxWindow *) 0 ;
38649 wxCaret *arg2 = (wxCaret *) 0 ;
38650 void *argp1 = 0 ;
38651 int res1 = 0 ;
38652 int res2 = 0 ;
38653 PyObject * obj0 = 0 ;
38654 PyObject * obj1 = 0 ;
38655 char * kwnames[] = {
38656 (char *) "self",(char *) "caret", NULL
38657 };
38658
38659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
38660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38661 if (!SWIG_IsOK(res1)) {
38662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
38663 }
38664 arg1 = reinterpret_cast< wxWindow * >(argp1);
38665 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
38666 if (!SWIG_IsOK(res2)) {
38667 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
38668 }
38669 {
38670 PyThreadState* __tstate = wxPyBeginAllowThreads();
38671 (arg1)->SetCaret(arg2);
38672 wxPyEndAllowThreads(__tstate);
38673 if (PyErr_Occurred()) SWIG_fail;
38674 }
38675 resultobj = SWIG_Py_Void();
38676 return resultobj;
38677 fail:
38678 return NULL;
38679 }
38680
38681
38682 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38683 PyObject *resultobj = 0;
38684 wxWindow *arg1 = (wxWindow *) 0 ;
38685 wxCaret *result = 0 ;
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_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
38695 }
38696 arg1 = reinterpret_cast< wxWindow * >(argp1);
38697 {
38698 PyThreadState* __tstate = wxPyBeginAllowThreads();
38699 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
38700 wxPyEndAllowThreads(__tstate);
38701 if (PyErr_Occurred()) SWIG_fail;
38702 }
38703 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
38704 return resultobj;
38705 fail:
38706 return NULL;
38707 }
38708
38709
38710 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38711 PyObject *resultobj = 0;
38712 wxWindow *arg1 = (wxWindow *) 0 ;
38713 int result;
38714 void *argp1 = 0 ;
38715 int res1 = 0 ;
38716 PyObject *swig_obj[1] ;
38717
38718 if (!args) SWIG_fail;
38719 swig_obj[0] = args;
38720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38721 if (!SWIG_IsOK(res1)) {
38722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
38723 }
38724 arg1 = reinterpret_cast< wxWindow * >(argp1);
38725 {
38726 PyThreadState* __tstate = wxPyBeginAllowThreads();
38727 result = (int)((wxWindow const *)arg1)->GetCharHeight();
38728 wxPyEndAllowThreads(__tstate);
38729 if (PyErr_Occurred()) SWIG_fail;
38730 }
38731 resultobj = SWIG_From_int(static_cast< int >(result));
38732 return resultobj;
38733 fail:
38734 return NULL;
38735 }
38736
38737
38738 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38739 PyObject *resultobj = 0;
38740 wxWindow *arg1 = (wxWindow *) 0 ;
38741 int result;
38742 void *argp1 = 0 ;
38743 int res1 = 0 ;
38744 PyObject *swig_obj[1] ;
38745
38746 if (!args) SWIG_fail;
38747 swig_obj[0] = args;
38748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38749 if (!SWIG_IsOK(res1)) {
38750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
38751 }
38752 arg1 = reinterpret_cast< wxWindow * >(argp1);
38753 {
38754 PyThreadState* __tstate = wxPyBeginAllowThreads();
38755 result = (int)((wxWindow const *)arg1)->GetCharWidth();
38756 wxPyEndAllowThreads(__tstate);
38757 if (PyErr_Occurred()) SWIG_fail;
38758 }
38759 resultobj = SWIG_From_int(static_cast< int >(result));
38760 return resultobj;
38761 fail:
38762 return NULL;
38763 }
38764
38765
38766 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38767 PyObject *resultobj = 0;
38768 wxWindow *arg1 = (wxWindow *) 0 ;
38769 wxString *arg2 = 0 ;
38770 int *arg3 = (int *) 0 ;
38771 int *arg4 = (int *) 0 ;
38772 void *argp1 = 0 ;
38773 int res1 = 0 ;
38774 bool temp2 = false ;
38775 int temp3 ;
38776 int res3 = SWIG_TMPOBJ ;
38777 int temp4 ;
38778 int res4 = SWIG_TMPOBJ ;
38779 PyObject * obj0 = 0 ;
38780 PyObject * obj1 = 0 ;
38781 char * kwnames[] = {
38782 (char *) "self",(char *) "string", NULL
38783 };
38784
38785 arg3 = &temp3;
38786 arg4 = &temp4;
38787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
38788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38789 if (!SWIG_IsOK(res1)) {
38790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
38791 }
38792 arg1 = reinterpret_cast< wxWindow * >(argp1);
38793 {
38794 arg2 = wxString_in_helper(obj1);
38795 if (arg2 == NULL) SWIG_fail;
38796 temp2 = true;
38797 }
38798 {
38799 PyThreadState* __tstate = wxPyBeginAllowThreads();
38800 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
38801 wxPyEndAllowThreads(__tstate);
38802 if (PyErr_Occurred()) SWIG_fail;
38803 }
38804 resultobj = SWIG_Py_Void();
38805 if (SWIG_IsTmpObj(res3)) {
38806 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38807 } else {
38808 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38809 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38810 }
38811 if (SWIG_IsTmpObj(res4)) {
38812 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
38813 } else {
38814 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38815 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
38816 }
38817 {
38818 if (temp2)
38819 delete arg2;
38820 }
38821 return resultobj;
38822 fail:
38823 {
38824 if (temp2)
38825 delete arg2;
38826 }
38827 return NULL;
38828 }
38829
38830
38831 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38832 PyObject *resultobj = 0;
38833 wxWindow *arg1 = (wxWindow *) 0 ;
38834 wxString *arg2 = 0 ;
38835 int *arg3 = (int *) 0 ;
38836 int *arg4 = (int *) 0 ;
38837 int *arg5 = (int *) 0 ;
38838 int *arg6 = (int *) 0 ;
38839 wxFont *arg7 = (wxFont *) NULL ;
38840 void *argp1 = 0 ;
38841 int res1 = 0 ;
38842 bool temp2 = false ;
38843 int temp3 ;
38844 int res3 = SWIG_TMPOBJ ;
38845 int temp4 ;
38846 int res4 = SWIG_TMPOBJ ;
38847 int temp5 ;
38848 int res5 = SWIG_TMPOBJ ;
38849 int temp6 ;
38850 int res6 = SWIG_TMPOBJ ;
38851 void *argp7 = 0 ;
38852 int res7 = 0 ;
38853 PyObject * obj0 = 0 ;
38854 PyObject * obj1 = 0 ;
38855 PyObject * obj2 = 0 ;
38856 char * kwnames[] = {
38857 (char *) "self",(char *) "string",(char *) "font", NULL
38858 };
38859
38860 arg3 = &temp3;
38861 arg4 = &temp4;
38862 arg5 = &temp5;
38863 arg6 = &temp6;
38864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38866 if (!SWIG_IsOK(res1)) {
38867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
38868 }
38869 arg1 = reinterpret_cast< wxWindow * >(argp1);
38870 {
38871 arg2 = wxString_in_helper(obj1);
38872 if (arg2 == NULL) SWIG_fail;
38873 temp2 = true;
38874 }
38875 if (obj2) {
38876 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
38877 if (!SWIG_IsOK(res7)) {
38878 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
38879 }
38880 arg7 = reinterpret_cast< wxFont * >(argp7);
38881 }
38882 {
38883 PyThreadState* __tstate = wxPyBeginAllowThreads();
38884 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
38885 wxPyEndAllowThreads(__tstate);
38886 if (PyErr_Occurred()) SWIG_fail;
38887 }
38888 resultobj = SWIG_Py_Void();
38889 if (SWIG_IsTmpObj(res3)) {
38890 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38891 } else {
38892 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38893 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38894 }
38895 if (SWIG_IsTmpObj(res4)) {
38896 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
38897 } else {
38898 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38899 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
38900 }
38901 if (SWIG_IsTmpObj(res5)) {
38902 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
38903 } else {
38904 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38905 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
38906 }
38907 if (SWIG_IsTmpObj(res6)) {
38908 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
38909 } else {
38910 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38911 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
38912 }
38913 {
38914 if (temp2)
38915 delete arg2;
38916 }
38917 return resultobj;
38918 fail:
38919 {
38920 if (temp2)
38921 delete arg2;
38922 }
38923 return NULL;
38924 }
38925
38926
38927 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38928 PyObject *resultobj = 0;
38929 wxWindow *arg1 = (wxWindow *) 0 ;
38930 int *arg2 = (int *) 0 ;
38931 int *arg3 = (int *) 0 ;
38932 void *argp1 = 0 ;
38933 int res1 = 0 ;
38934 int temp2 ;
38935 int res2 = 0 ;
38936 int temp3 ;
38937 int res3 = 0 ;
38938 PyObject * obj0 = 0 ;
38939 PyObject * obj1 = 0 ;
38940 PyObject * obj2 = 0 ;
38941 char * kwnames[] = {
38942 (char *) "self",(char *) "x",(char *) "y", NULL
38943 };
38944
38945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38947 if (!SWIG_IsOK(res1)) {
38948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
38949 }
38950 arg1 = reinterpret_cast< wxWindow * >(argp1);
38951 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
38952 int val;
38953 int ecode = SWIG_AsVal_int(obj1, &val);
38954 if (!SWIG_IsOK(ecode)) {
38955 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
38956 }
38957 temp2 = static_cast< int >(val);
38958 arg2 = &temp2;
38959 res2 = SWIG_AddTmpMask(ecode);
38960 }
38961 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
38962 int val;
38963 int ecode = SWIG_AsVal_int(obj2, &val);
38964 if (!SWIG_IsOK(ecode)) {
38965 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
38966 }
38967 temp3 = static_cast< int >(val);
38968 arg3 = &temp3;
38969 res3 = SWIG_AddTmpMask(ecode);
38970 }
38971 {
38972 PyThreadState* __tstate = wxPyBeginAllowThreads();
38973 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
38974 wxPyEndAllowThreads(__tstate);
38975 if (PyErr_Occurred()) SWIG_fail;
38976 }
38977 resultobj = SWIG_Py_Void();
38978 if (SWIG_IsTmpObj(res2)) {
38979 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
38980 } else {
38981 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38982 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
38983 }
38984 if (SWIG_IsTmpObj(res3)) {
38985 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38986 } else {
38987 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38988 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38989 }
38990 return resultobj;
38991 fail:
38992 return NULL;
38993 }
38994
38995
38996 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38997 PyObject *resultobj = 0;
38998 wxWindow *arg1 = (wxWindow *) 0 ;
38999 int *arg2 = (int *) 0 ;
39000 int *arg3 = (int *) 0 ;
39001 void *argp1 = 0 ;
39002 int res1 = 0 ;
39003 int temp2 ;
39004 int res2 = 0 ;
39005 int temp3 ;
39006 int res3 = 0 ;
39007 PyObject * obj0 = 0 ;
39008 PyObject * obj1 = 0 ;
39009 PyObject * obj2 = 0 ;
39010 char * kwnames[] = {
39011 (char *) "self",(char *) "x",(char *) "y", NULL
39012 };
39013
39014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39016 if (!SWIG_IsOK(res1)) {
39017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39018 }
39019 arg1 = reinterpret_cast< wxWindow * >(argp1);
39020 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39021 int val;
39022 int ecode = SWIG_AsVal_int(obj1, &val);
39023 if (!SWIG_IsOK(ecode)) {
39024 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
39025 }
39026 temp2 = static_cast< int >(val);
39027 arg2 = &temp2;
39028 res2 = SWIG_AddTmpMask(ecode);
39029 }
39030 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39031 int val;
39032 int ecode = SWIG_AsVal_int(obj2, &val);
39033 if (!SWIG_IsOK(ecode)) {
39034 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
39035 }
39036 temp3 = static_cast< int >(val);
39037 arg3 = &temp3;
39038 res3 = SWIG_AddTmpMask(ecode);
39039 }
39040 {
39041 PyThreadState* __tstate = wxPyBeginAllowThreads();
39042 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
39043 wxPyEndAllowThreads(__tstate);
39044 if (PyErr_Occurred()) SWIG_fail;
39045 }
39046 resultobj = SWIG_Py_Void();
39047 if (SWIG_IsTmpObj(res2)) {
39048 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39049 } else {
39050 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39051 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39052 }
39053 if (SWIG_IsTmpObj(res3)) {
39054 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39055 } else {
39056 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39057 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39058 }
39059 return resultobj;
39060 fail:
39061 return NULL;
39062 }
39063
39064
39065 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39066 PyObject *resultobj = 0;
39067 wxWindow *arg1 = (wxWindow *) 0 ;
39068 wxPoint *arg2 = 0 ;
39069 wxPoint result;
39070 void *argp1 = 0 ;
39071 int res1 = 0 ;
39072 wxPoint temp2 ;
39073 PyObject * obj0 = 0 ;
39074 PyObject * obj1 = 0 ;
39075 char * kwnames[] = {
39076 (char *) "self",(char *) "pt", NULL
39077 };
39078
39079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
39080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39081 if (!SWIG_IsOK(res1)) {
39082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
39083 }
39084 arg1 = reinterpret_cast< wxWindow * >(argp1);
39085 {
39086 arg2 = &temp2;
39087 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39088 }
39089 {
39090 PyThreadState* __tstate = wxPyBeginAllowThreads();
39091 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
39092 wxPyEndAllowThreads(__tstate);
39093 if (PyErr_Occurred()) SWIG_fail;
39094 }
39095 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39096 return resultobj;
39097 fail:
39098 return NULL;
39099 }
39100
39101
39102 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39103 PyObject *resultobj = 0;
39104 wxWindow *arg1 = (wxWindow *) 0 ;
39105 wxPoint *arg2 = 0 ;
39106 wxPoint result;
39107 void *argp1 = 0 ;
39108 int res1 = 0 ;
39109 wxPoint temp2 ;
39110 PyObject * obj0 = 0 ;
39111 PyObject * obj1 = 0 ;
39112 char * kwnames[] = {
39113 (char *) "self",(char *) "pt", NULL
39114 };
39115
39116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
39117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39118 if (!SWIG_IsOK(res1)) {
39119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
39120 }
39121 arg1 = reinterpret_cast< wxWindow * >(argp1);
39122 {
39123 arg2 = &temp2;
39124 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39125 }
39126 {
39127 PyThreadState* __tstate = wxPyBeginAllowThreads();
39128 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
39129 wxPyEndAllowThreads(__tstate);
39130 if (PyErr_Occurred()) SWIG_fail;
39131 }
39132 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39133 return resultobj;
39134 fail:
39135 return NULL;
39136 }
39137
39138
39139 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39140 PyObject *resultobj = 0;
39141 wxWindow *arg1 = (wxWindow *) 0 ;
39142 int arg2 ;
39143 int arg3 ;
39144 wxHitTest result;
39145 void *argp1 = 0 ;
39146 int res1 = 0 ;
39147 int val2 ;
39148 int ecode2 = 0 ;
39149 int val3 ;
39150 int ecode3 = 0 ;
39151 PyObject * obj0 = 0 ;
39152 PyObject * obj1 = 0 ;
39153 PyObject * obj2 = 0 ;
39154 char * kwnames[] = {
39155 (char *) "self",(char *) "x",(char *) "y", NULL
39156 };
39157
39158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39160 if (!SWIG_IsOK(res1)) {
39161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39162 }
39163 arg1 = reinterpret_cast< wxWindow * >(argp1);
39164 ecode2 = SWIG_AsVal_int(obj1, &val2);
39165 if (!SWIG_IsOK(ecode2)) {
39166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
39167 }
39168 arg2 = static_cast< int >(val2);
39169 ecode3 = SWIG_AsVal_int(obj2, &val3);
39170 if (!SWIG_IsOK(ecode3)) {
39171 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
39172 }
39173 arg3 = static_cast< int >(val3);
39174 {
39175 PyThreadState* __tstate = wxPyBeginAllowThreads();
39176 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
39177 wxPyEndAllowThreads(__tstate);
39178 if (PyErr_Occurred()) SWIG_fail;
39179 }
39180 resultobj = SWIG_From_int(static_cast< int >(result));
39181 return resultobj;
39182 fail:
39183 return NULL;
39184 }
39185
39186
39187 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39188 PyObject *resultobj = 0;
39189 wxWindow *arg1 = (wxWindow *) 0 ;
39190 wxPoint *arg2 = 0 ;
39191 wxHitTest result;
39192 void *argp1 = 0 ;
39193 int res1 = 0 ;
39194 wxPoint temp2 ;
39195 PyObject * obj0 = 0 ;
39196 PyObject * obj1 = 0 ;
39197 char * kwnames[] = {
39198 (char *) "self",(char *) "pt", NULL
39199 };
39200
39201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
39202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39203 if (!SWIG_IsOK(res1)) {
39204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
39205 }
39206 arg1 = reinterpret_cast< wxWindow * >(argp1);
39207 {
39208 arg2 = &temp2;
39209 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39210 }
39211 {
39212 PyThreadState* __tstate = wxPyBeginAllowThreads();
39213 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
39214 wxPyEndAllowThreads(__tstate);
39215 if (PyErr_Occurred()) SWIG_fail;
39216 }
39217 resultobj = SWIG_From_int(static_cast< int >(result));
39218 return resultobj;
39219 fail:
39220 return NULL;
39221 }
39222
39223
39224 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39225 PyObject *resultobj = 0;
39226 wxWindow *arg1 = (wxWindow *) 0 ;
39227 long arg2 ;
39228 wxBorder result;
39229 void *argp1 = 0 ;
39230 int res1 = 0 ;
39231 long val2 ;
39232 int ecode2 = 0 ;
39233
39234 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
39235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39236 if (!SWIG_IsOK(res1)) {
39237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39238 }
39239 arg1 = reinterpret_cast< wxWindow * >(argp1);
39240 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
39241 if (!SWIG_IsOK(ecode2)) {
39242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
39243 }
39244 arg2 = static_cast< long >(val2);
39245 {
39246 PyThreadState* __tstate = wxPyBeginAllowThreads();
39247 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
39248 wxPyEndAllowThreads(__tstate);
39249 if (PyErr_Occurred()) SWIG_fail;
39250 }
39251 resultobj = SWIG_From_int(static_cast< int >(result));
39252 return resultobj;
39253 fail:
39254 return NULL;
39255 }
39256
39257
39258 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39259 PyObject *resultobj = 0;
39260 wxWindow *arg1 = (wxWindow *) 0 ;
39261 wxBorder result;
39262 void *argp1 = 0 ;
39263 int res1 = 0 ;
39264
39265 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
39266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39267 if (!SWIG_IsOK(res1)) {
39268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39269 }
39270 arg1 = reinterpret_cast< wxWindow * >(argp1);
39271 {
39272 PyThreadState* __tstate = wxPyBeginAllowThreads();
39273 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
39274 wxPyEndAllowThreads(__tstate);
39275 if (PyErr_Occurred()) SWIG_fail;
39276 }
39277 resultobj = SWIG_From_int(static_cast< int >(result));
39278 return resultobj;
39279 fail:
39280 return NULL;
39281 }
39282
39283
39284 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
39285 int argc;
39286 PyObject *argv[3];
39287
39288 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
39289 --argc;
39290 if (argc == 1) {
39291 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
39292 }
39293 if (argc == 2) {
39294 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
39295 }
39296
39297 fail:
39298 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
39299 return NULL;
39300 }
39301
39302
39303 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39304 PyObject *resultobj = 0;
39305 wxWindow *arg1 = (wxWindow *) 0 ;
39306 long arg2 = (long) wxUPDATE_UI_NONE ;
39307 void *argp1 = 0 ;
39308 int res1 = 0 ;
39309 long val2 ;
39310 int ecode2 = 0 ;
39311 PyObject * obj0 = 0 ;
39312 PyObject * obj1 = 0 ;
39313 char * kwnames[] = {
39314 (char *) "self",(char *) "flags", NULL
39315 };
39316
39317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
39318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39319 if (!SWIG_IsOK(res1)) {
39320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
39321 }
39322 arg1 = reinterpret_cast< wxWindow * >(argp1);
39323 if (obj1) {
39324 ecode2 = SWIG_AsVal_long(obj1, &val2);
39325 if (!SWIG_IsOK(ecode2)) {
39326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
39327 }
39328 arg2 = static_cast< long >(val2);
39329 }
39330 {
39331 PyThreadState* __tstate = wxPyBeginAllowThreads();
39332 (arg1)->UpdateWindowUI(arg2);
39333 wxPyEndAllowThreads(__tstate);
39334 if (PyErr_Occurred()) SWIG_fail;
39335 }
39336 resultobj = SWIG_Py_Void();
39337 return resultobj;
39338 fail:
39339 return NULL;
39340 }
39341
39342
39343 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39344 PyObject *resultobj = 0;
39345 wxWindow *arg1 = (wxWindow *) 0 ;
39346 wxMenu *arg2 = (wxMenu *) 0 ;
39347 int arg3 = (int) -1 ;
39348 int arg4 = (int) -1 ;
39349 bool result;
39350 void *argp1 = 0 ;
39351 int res1 = 0 ;
39352 void *argp2 = 0 ;
39353 int res2 = 0 ;
39354 int val3 ;
39355 int ecode3 = 0 ;
39356 int val4 ;
39357 int ecode4 = 0 ;
39358 PyObject * obj0 = 0 ;
39359 PyObject * obj1 = 0 ;
39360 PyObject * obj2 = 0 ;
39361 PyObject * obj3 = 0 ;
39362 char * kwnames[] = {
39363 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
39364 };
39365
39366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39368 if (!SWIG_IsOK(res1)) {
39369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
39370 }
39371 arg1 = reinterpret_cast< wxWindow * >(argp1);
39372 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39373 if (!SWIG_IsOK(res2)) {
39374 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
39375 }
39376 arg2 = reinterpret_cast< wxMenu * >(argp2);
39377 if (obj2) {
39378 ecode3 = SWIG_AsVal_int(obj2, &val3);
39379 if (!SWIG_IsOK(ecode3)) {
39380 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
39381 }
39382 arg3 = static_cast< int >(val3);
39383 }
39384 if (obj3) {
39385 ecode4 = SWIG_AsVal_int(obj3, &val4);
39386 if (!SWIG_IsOK(ecode4)) {
39387 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
39388 }
39389 arg4 = static_cast< int >(val4);
39390 }
39391 {
39392 PyThreadState* __tstate = wxPyBeginAllowThreads();
39393 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
39394 wxPyEndAllowThreads(__tstate);
39395 if (PyErr_Occurred()) SWIG_fail;
39396 }
39397 {
39398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39399 }
39400 return resultobj;
39401 fail:
39402 return NULL;
39403 }
39404
39405
39406 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39407 PyObject *resultobj = 0;
39408 wxWindow *arg1 = (wxWindow *) 0 ;
39409 wxMenu *arg2 = (wxMenu *) 0 ;
39410 wxPoint const &arg3_defvalue = wxDefaultPosition ;
39411 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
39412 bool result;
39413 void *argp1 = 0 ;
39414 int res1 = 0 ;
39415 void *argp2 = 0 ;
39416 int res2 = 0 ;
39417 wxPoint temp3 ;
39418 PyObject * obj0 = 0 ;
39419 PyObject * obj1 = 0 ;
39420 PyObject * obj2 = 0 ;
39421 char * kwnames[] = {
39422 (char *) "self",(char *) "menu",(char *) "pos", NULL
39423 };
39424
39425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39427 if (!SWIG_IsOK(res1)) {
39428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
39429 }
39430 arg1 = reinterpret_cast< wxWindow * >(argp1);
39431 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39432 if (!SWIG_IsOK(res2)) {
39433 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39434 }
39435 arg2 = reinterpret_cast< wxMenu * >(argp2);
39436 if (obj2) {
39437 {
39438 arg3 = &temp3;
39439 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
39440 }
39441 }
39442 {
39443 PyThreadState* __tstate = wxPyBeginAllowThreads();
39444 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
39445 wxPyEndAllowThreads(__tstate);
39446 if (PyErr_Occurred()) SWIG_fail;
39447 }
39448 {
39449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39450 }
39451 return resultobj;
39452 fail:
39453 return NULL;
39454 }
39455
39456
39457 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39458 PyObject *resultobj = 0;
39459 wxWindow *arg1 = (wxWindow *) 0 ;
39460 bool result;
39461 void *argp1 = 0 ;
39462 int res1 = 0 ;
39463 PyObject *swig_obj[1] ;
39464
39465 if (!args) SWIG_fail;
39466 swig_obj[0] = args;
39467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39468 if (!SWIG_IsOK(res1)) {
39469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
39470 }
39471 arg1 = reinterpret_cast< wxWindow * >(argp1);
39472 {
39473 PyThreadState* __tstate = wxPyBeginAllowThreads();
39474 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
39475 wxPyEndAllowThreads(__tstate);
39476 if (PyErr_Occurred()) SWIG_fail;
39477 }
39478 {
39479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39480 }
39481 return resultobj;
39482 fail:
39483 return NULL;
39484 }
39485
39486
39487 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39488 PyObject *resultobj = 0;
39489 wxWindow *arg1 = (wxWindow *) 0 ;
39490 long result;
39491 void *argp1 = 0 ;
39492 int res1 = 0 ;
39493 PyObject *swig_obj[1] ;
39494
39495 if (!args) SWIG_fail;
39496 swig_obj[0] = args;
39497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39498 if (!SWIG_IsOK(res1)) {
39499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39500 }
39501 arg1 = reinterpret_cast< wxWindow * >(argp1);
39502 {
39503 PyThreadState* __tstate = wxPyBeginAllowThreads();
39504 result = (long)wxWindow_GetHandle(arg1);
39505 wxPyEndAllowThreads(__tstate);
39506 if (PyErr_Occurred()) SWIG_fail;
39507 }
39508 resultobj = SWIG_From_long(static_cast< long >(result));
39509 return resultobj;
39510 fail:
39511 return NULL;
39512 }
39513
39514
39515 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39516 PyObject *resultobj = 0;
39517 wxWindow *arg1 = (wxWindow *) 0 ;
39518 long arg2 ;
39519 void *argp1 = 0 ;
39520 int res1 = 0 ;
39521 long val2 ;
39522 int ecode2 = 0 ;
39523 PyObject * obj0 = 0 ;
39524 PyObject * obj1 = 0 ;
39525 char * kwnames[] = {
39526 (char *) "self",(char *) "handle", NULL
39527 };
39528
39529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
39530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39531 if (!SWIG_IsOK(res1)) {
39532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39533 }
39534 arg1 = reinterpret_cast< wxWindow * >(argp1);
39535 ecode2 = SWIG_AsVal_long(obj1, &val2);
39536 if (!SWIG_IsOK(ecode2)) {
39537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
39538 }
39539 arg2 = static_cast< long >(val2);
39540 {
39541 PyThreadState* __tstate = wxPyBeginAllowThreads();
39542 wxWindow_AssociateHandle(arg1,arg2);
39543 wxPyEndAllowThreads(__tstate);
39544 if (PyErr_Occurred()) SWIG_fail;
39545 }
39546 resultobj = SWIG_Py_Void();
39547 return resultobj;
39548 fail:
39549 return NULL;
39550 }
39551
39552
39553 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39554 PyObject *resultobj = 0;
39555 wxWindow *arg1 = (wxWindow *) 0 ;
39556 void *argp1 = 0 ;
39557 int res1 = 0 ;
39558 PyObject *swig_obj[1] ;
39559
39560 if (!args) SWIG_fail;
39561 swig_obj[0] = args;
39562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39563 if (!SWIG_IsOK(res1)) {
39564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39565 }
39566 arg1 = reinterpret_cast< wxWindow * >(argp1);
39567 {
39568 PyThreadState* __tstate = wxPyBeginAllowThreads();
39569 (arg1)->DissociateHandle();
39570 wxPyEndAllowThreads(__tstate);
39571 if (PyErr_Occurred()) SWIG_fail;
39572 }
39573 resultobj = SWIG_Py_Void();
39574 return resultobj;
39575 fail:
39576 return NULL;
39577 }
39578
39579
39580 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39581 PyObject *resultobj = 0;
39582 wxWindow *arg1 = (wxWindow *) 0 ;
39583 int arg2 ;
39584 bool result;
39585 void *argp1 = 0 ;
39586 int res1 = 0 ;
39587 int val2 ;
39588 int ecode2 = 0 ;
39589 PyObject * obj0 = 0 ;
39590 PyObject * obj1 = 0 ;
39591 char * kwnames[] = {
39592 (char *) "self",(char *) "orient", NULL
39593 };
39594
39595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
39596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39597 if (!SWIG_IsOK(res1)) {
39598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
39599 }
39600 arg1 = reinterpret_cast< wxWindow * >(argp1);
39601 ecode2 = SWIG_AsVal_int(obj1, &val2);
39602 if (!SWIG_IsOK(ecode2)) {
39603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
39604 }
39605 arg2 = static_cast< int >(val2);
39606 {
39607 PyThreadState* __tstate = wxPyBeginAllowThreads();
39608 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
39609 wxPyEndAllowThreads(__tstate);
39610 if (PyErr_Occurred()) SWIG_fail;
39611 }
39612 {
39613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39614 }
39615 return resultobj;
39616 fail:
39617 return NULL;
39618 }
39619
39620
39621 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39622 PyObject *resultobj = 0;
39623 wxWindow *arg1 = (wxWindow *) 0 ;
39624 int arg2 ;
39625 int arg3 ;
39626 int arg4 ;
39627 int arg5 ;
39628 bool arg6 = (bool) true ;
39629 void *argp1 = 0 ;
39630 int res1 = 0 ;
39631 int val2 ;
39632 int ecode2 = 0 ;
39633 int val3 ;
39634 int ecode3 = 0 ;
39635 int val4 ;
39636 int ecode4 = 0 ;
39637 int val5 ;
39638 int ecode5 = 0 ;
39639 bool val6 ;
39640 int ecode6 = 0 ;
39641 PyObject * obj0 = 0 ;
39642 PyObject * obj1 = 0 ;
39643 PyObject * obj2 = 0 ;
39644 PyObject * obj3 = 0 ;
39645 PyObject * obj4 = 0 ;
39646 PyObject * obj5 = 0 ;
39647 char * kwnames[] = {
39648 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
39649 };
39650
39651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39653 if (!SWIG_IsOK(res1)) {
39654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
39655 }
39656 arg1 = reinterpret_cast< wxWindow * >(argp1);
39657 ecode2 = SWIG_AsVal_int(obj1, &val2);
39658 if (!SWIG_IsOK(ecode2)) {
39659 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
39660 }
39661 arg2 = static_cast< int >(val2);
39662 ecode3 = SWIG_AsVal_int(obj2, &val3);
39663 if (!SWIG_IsOK(ecode3)) {
39664 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
39665 }
39666 arg3 = static_cast< int >(val3);
39667 ecode4 = SWIG_AsVal_int(obj3, &val4);
39668 if (!SWIG_IsOK(ecode4)) {
39669 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
39670 }
39671 arg4 = static_cast< int >(val4);
39672 ecode5 = SWIG_AsVal_int(obj4, &val5);
39673 if (!SWIG_IsOK(ecode5)) {
39674 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
39675 }
39676 arg5 = static_cast< int >(val5);
39677 if (obj5) {
39678 ecode6 = SWIG_AsVal_bool(obj5, &val6);
39679 if (!SWIG_IsOK(ecode6)) {
39680 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
39681 }
39682 arg6 = static_cast< bool >(val6);
39683 }
39684 {
39685 PyThreadState* __tstate = wxPyBeginAllowThreads();
39686 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
39687 wxPyEndAllowThreads(__tstate);
39688 if (PyErr_Occurred()) SWIG_fail;
39689 }
39690 resultobj = SWIG_Py_Void();
39691 return resultobj;
39692 fail:
39693 return NULL;
39694 }
39695
39696
39697 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39698 PyObject *resultobj = 0;
39699 wxWindow *arg1 = (wxWindow *) 0 ;
39700 int arg2 ;
39701 int arg3 ;
39702 bool arg4 = (bool) true ;
39703 void *argp1 = 0 ;
39704 int res1 = 0 ;
39705 int val2 ;
39706 int ecode2 = 0 ;
39707 int val3 ;
39708 int ecode3 = 0 ;
39709 bool val4 ;
39710 int ecode4 = 0 ;
39711 PyObject * obj0 = 0 ;
39712 PyObject * obj1 = 0 ;
39713 PyObject * obj2 = 0 ;
39714 PyObject * obj3 = 0 ;
39715 char * kwnames[] = {
39716 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
39717 };
39718
39719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39721 if (!SWIG_IsOK(res1)) {
39722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
39723 }
39724 arg1 = reinterpret_cast< wxWindow * >(argp1);
39725 ecode2 = SWIG_AsVal_int(obj1, &val2);
39726 if (!SWIG_IsOK(ecode2)) {
39727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
39728 }
39729 arg2 = static_cast< int >(val2);
39730 ecode3 = SWIG_AsVal_int(obj2, &val3);
39731 if (!SWIG_IsOK(ecode3)) {
39732 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
39733 }
39734 arg3 = static_cast< int >(val3);
39735 if (obj3) {
39736 ecode4 = SWIG_AsVal_bool(obj3, &val4);
39737 if (!SWIG_IsOK(ecode4)) {
39738 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
39739 }
39740 arg4 = static_cast< bool >(val4);
39741 }
39742 {
39743 PyThreadState* __tstate = wxPyBeginAllowThreads();
39744 (arg1)->SetScrollPos(arg2,arg3,arg4);
39745 wxPyEndAllowThreads(__tstate);
39746 if (PyErr_Occurred()) SWIG_fail;
39747 }
39748 resultobj = SWIG_Py_Void();
39749 return resultobj;
39750 fail:
39751 return NULL;
39752 }
39753
39754
39755 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39756 PyObject *resultobj = 0;
39757 wxWindow *arg1 = (wxWindow *) 0 ;
39758 int arg2 ;
39759 int result;
39760 void *argp1 = 0 ;
39761 int res1 = 0 ;
39762 int val2 ;
39763 int ecode2 = 0 ;
39764 PyObject * obj0 = 0 ;
39765 PyObject * obj1 = 0 ;
39766 char * kwnames[] = {
39767 (char *) "self",(char *) "orientation", NULL
39768 };
39769
39770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
39771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39772 if (!SWIG_IsOK(res1)) {
39773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
39774 }
39775 arg1 = reinterpret_cast< wxWindow * >(argp1);
39776 ecode2 = SWIG_AsVal_int(obj1, &val2);
39777 if (!SWIG_IsOK(ecode2)) {
39778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
39779 }
39780 arg2 = static_cast< int >(val2);
39781 {
39782 PyThreadState* __tstate = wxPyBeginAllowThreads();
39783 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
39784 wxPyEndAllowThreads(__tstate);
39785 if (PyErr_Occurred()) SWIG_fail;
39786 }
39787 resultobj = SWIG_From_int(static_cast< int >(result));
39788 return resultobj;
39789 fail:
39790 return NULL;
39791 }
39792
39793
39794 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39795 PyObject *resultobj = 0;
39796 wxWindow *arg1 = (wxWindow *) 0 ;
39797 int arg2 ;
39798 int result;
39799 void *argp1 = 0 ;
39800 int res1 = 0 ;
39801 int val2 ;
39802 int ecode2 = 0 ;
39803 PyObject * obj0 = 0 ;
39804 PyObject * obj1 = 0 ;
39805 char * kwnames[] = {
39806 (char *) "self",(char *) "orientation", NULL
39807 };
39808
39809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
39810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39811 if (!SWIG_IsOK(res1)) {
39812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
39813 }
39814 arg1 = reinterpret_cast< wxWindow * >(argp1);
39815 ecode2 = SWIG_AsVal_int(obj1, &val2);
39816 if (!SWIG_IsOK(ecode2)) {
39817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
39818 }
39819 arg2 = static_cast< int >(val2);
39820 {
39821 PyThreadState* __tstate = wxPyBeginAllowThreads();
39822 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
39823 wxPyEndAllowThreads(__tstate);
39824 if (PyErr_Occurred()) SWIG_fail;
39825 }
39826 resultobj = SWIG_From_int(static_cast< int >(result));
39827 return resultobj;
39828 fail:
39829 return NULL;
39830 }
39831
39832
39833 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39834 PyObject *resultobj = 0;
39835 wxWindow *arg1 = (wxWindow *) 0 ;
39836 int arg2 ;
39837 int result;
39838 void *argp1 = 0 ;
39839 int res1 = 0 ;
39840 int val2 ;
39841 int ecode2 = 0 ;
39842 PyObject * obj0 = 0 ;
39843 PyObject * obj1 = 0 ;
39844 char * kwnames[] = {
39845 (char *) "self",(char *) "orientation", NULL
39846 };
39847
39848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
39849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39850 if (!SWIG_IsOK(res1)) {
39851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
39852 }
39853 arg1 = reinterpret_cast< wxWindow * >(argp1);
39854 ecode2 = SWIG_AsVal_int(obj1, &val2);
39855 if (!SWIG_IsOK(ecode2)) {
39856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
39857 }
39858 arg2 = static_cast< int >(val2);
39859 {
39860 PyThreadState* __tstate = wxPyBeginAllowThreads();
39861 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
39862 wxPyEndAllowThreads(__tstate);
39863 if (PyErr_Occurred()) SWIG_fail;
39864 }
39865 resultobj = SWIG_From_int(static_cast< int >(result));
39866 return resultobj;
39867 fail:
39868 return NULL;
39869 }
39870
39871
39872 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39873 PyObject *resultobj = 0;
39874 wxWindow *arg1 = (wxWindow *) 0 ;
39875 int arg2 ;
39876 int arg3 ;
39877 wxRect *arg4 = (wxRect *) NULL ;
39878 void *argp1 = 0 ;
39879 int res1 = 0 ;
39880 int val2 ;
39881 int ecode2 = 0 ;
39882 int val3 ;
39883 int ecode3 = 0 ;
39884 void *argp4 = 0 ;
39885 int res4 = 0 ;
39886 PyObject * obj0 = 0 ;
39887 PyObject * obj1 = 0 ;
39888 PyObject * obj2 = 0 ;
39889 PyObject * obj3 = 0 ;
39890 char * kwnames[] = {
39891 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
39892 };
39893
39894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39896 if (!SWIG_IsOK(res1)) {
39897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
39898 }
39899 arg1 = reinterpret_cast< wxWindow * >(argp1);
39900 ecode2 = SWIG_AsVal_int(obj1, &val2);
39901 if (!SWIG_IsOK(ecode2)) {
39902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
39903 }
39904 arg2 = static_cast< int >(val2);
39905 ecode3 = SWIG_AsVal_int(obj2, &val3);
39906 if (!SWIG_IsOK(ecode3)) {
39907 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
39908 }
39909 arg3 = static_cast< int >(val3);
39910 if (obj3) {
39911 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
39912 if (!SWIG_IsOK(res4)) {
39913 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
39914 }
39915 arg4 = reinterpret_cast< wxRect * >(argp4);
39916 }
39917 {
39918 PyThreadState* __tstate = wxPyBeginAllowThreads();
39919 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
39920 wxPyEndAllowThreads(__tstate);
39921 if (PyErr_Occurred()) SWIG_fail;
39922 }
39923 resultobj = SWIG_Py_Void();
39924 return resultobj;
39925 fail:
39926 return NULL;
39927 }
39928
39929
39930 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39931 PyObject *resultobj = 0;
39932 wxWindow *arg1 = (wxWindow *) 0 ;
39933 int arg2 ;
39934 bool result;
39935 void *argp1 = 0 ;
39936 int res1 = 0 ;
39937 int val2 ;
39938 int ecode2 = 0 ;
39939 PyObject * obj0 = 0 ;
39940 PyObject * obj1 = 0 ;
39941 char * kwnames[] = {
39942 (char *) "self",(char *) "lines", NULL
39943 };
39944
39945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
39946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39947 if (!SWIG_IsOK(res1)) {
39948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
39949 }
39950 arg1 = reinterpret_cast< wxWindow * >(argp1);
39951 ecode2 = SWIG_AsVal_int(obj1, &val2);
39952 if (!SWIG_IsOK(ecode2)) {
39953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
39954 }
39955 arg2 = static_cast< int >(val2);
39956 {
39957 PyThreadState* __tstate = wxPyBeginAllowThreads();
39958 result = (bool)(arg1)->ScrollLines(arg2);
39959 wxPyEndAllowThreads(__tstate);
39960 if (PyErr_Occurred()) SWIG_fail;
39961 }
39962 {
39963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39964 }
39965 return resultobj;
39966 fail:
39967 return NULL;
39968 }
39969
39970
39971 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39972 PyObject *resultobj = 0;
39973 wxWindow *arg1 = (wxWindow *) 0 ;
39974 int arg2 ;
39975 bool result;
39976 void *argp1 = 0 ;
39977 int res1 = 0 ;
39978 int val2 ;
39979 int ecode2 = 0 ;
39980 PyObject * obj0 = 0 ;
39981 PyObject * obj1 = 0 ;
39982 char * kwnames[] = {
39983 (char *) "self",(char *) "pages", NULL
39984 };
39985
39986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
39987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39988 if (!SWIG_IsOK(res1)) {
39989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
39990 }
39991 arg1 = reinterpret_cast< wxWindow * >(argp1);
39992 ecode2 = SWIG_AsVal_int(obj1, &val2);
39993 if (!SWIG_IsOK(ecode2)) {
39994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
39995 }
39996 arg2 = static_cast< int >(val2);
39997 {
39998 PyThreadState* __tstate = wxPyBeginAllowThreads();
39999 result = (bool)(arg1)->ScrollPages(arg2);
40000 wxPyEndAllowThreads(__tstate);
40001 if (PyErr_Occurred()) SWIG_fail;
40002 }
40003 {
40004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40005 }
40006 return resultobj;
40007 fail:
40008 return NULL;
40009 }
40010
40011
40012 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40013 PyObject *resultobj = 0;
40014 wxWindow *arg1 = (wxWindow *) 0 ;
40015 bool result;
40016 void *argp1 = 0 ;
40017 int res1 = 0 ;
40018 PyObject *swig_obj[1] ;
40019
40020 if (!args) SWIG_fail;
40021 swig_obj[0] = args;
40022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40023 if (!SWIG_IsOK(res1)) {
40024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40025 }
40026 arg1 = reinterpret_cast< wxWindow * >(argp1);
40027 {
40028 PyThreadState* __tstate = wxPyBeginAllowThreads();
40029 result = (bool)(arg1)->LineUp();
40030 wxPyEndAllowThreads(__tstate);
40031 if (PyErr_Occurred()) SWIG_fail;
40032 }
40033 {
40034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40035 }
40036 return resultobj;
40037 fail:
40038 return NULL;
40039 }
40040
40041
40042 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40043 PyObject *resultobj = 0;
40044 wxWindow *arg1 = (wxWindow *) 0 ;
40045 bool result;
40046 void *argp1 = 0 ;
40047 int res1 = 0 ;
40048 PyObject *swig_obj[1] ;
40049
40050 if (!args) SWIG_fail;
40051 swig_obj[0] = args;
40052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40053 if (!SWIG_IsOK(res1)) {
40054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40055 }
40056 arg1 = reinterpret_cast< wxWindow * >(argp1);
40057 {
40058 PyThreadState* __tstate = wxPyBeginAllowThreads();
40059 result = (bool)(arg1)->LineDown();
40060 wxPyEndAllowThreads(__tstate);
40061 if (PyErr_Occurred()) SWIG_fail;
40062 }
40063 {
40064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40065 }
40066 return resultobj;
40067 fail:
40068 return NULL;
40069 }
40070
40071
40072 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40073 PyObject *resultobj = 0;
40074 wxWindow *arg1 = (wxWindow *) 0 ;
40075 bool result;
40076 void *argp1 = 0 ;
40077 int res1 = 0 ;
40078 PyObject *swig_obj[1] ;
40079
40080 if (!args) SWIG_fail;
40081 swig_obj[0] = args;
40082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40083 if (!SWIG_IsOK(res1)) {
40084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40085 }
40086 arg1 = reinterpret_cast< wxWindow * >(argp1);
40087 {
40088 PyThreadState* __tstate = wxPyBeginAllowThreads();
40089 result = (bool)(arg1)->PageUp();
40090 wxPyEndAllowThreads(__tstate);
40091 if (PyErr_Occurred()) SWIG_fail;
40092 }
40093 {
40094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40095 }
40096 return resultobj;
40097 fail:
40098 return NULL;
40099 }
40100
40101
40102 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40103 PyObject *resultobj = 0;
40104 wxWindow *arg1 = (wxWindow *) 0 ;
40105 bool result;
40106 void *argp1 = 0 ;
40107 int res1 = 0 ;
40108 PyObject *swig_obj[1] ;
40109
40110 if (!args) SWIG_fail;
40111 swig_obj[0] = args;
40112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40113 if (!SWIG_IsOK(res1)) {
40114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40115 }
40116 arg1 = reinterpret_cast< wxWindow * >(argp1);
40117 {
40118 PyThreadState* __tstate = wxPyBeginAllowThreads();
40119 result = (bool)(arg1)->PageDown();
40120 wxPyEndAllowThreads(__tstate);
40121 if (PyErr_Occurred()) SWIG_fail;
40122 }
40123 {
40124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40125 }
40126 return resultobj;
40127 fail:
40128 return NULL;
40129 }
40130
40131
40132 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40133 PyObject *resultobj = 0;
40134 wxWindow *arg1 = (wxWindow *) 0 ;
40135 wxString *arg2 = 0 ;
40136 void *argp1 = 0 ;
40137 int res1 = 0 ;
40138 bool temp2 = false ;
40139 PyObject * obj0 = 0 ;
40140 PyObject * obj1 = 0 ;
40141 char * kwnames[] = {
40142 (char *) "self",(char *) "text", NULL
40143 };
40144
40145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
40146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40147 if (!SWIG_IsOK(res1)) {
40148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
40149 }
40150 arg1 = reinterpret_cast< wxWindow * >(argp1);
40151 {
40152 arg2 = wxString_in_helper(obj1);
40153 if (arg2 == NULL) SWIG_fail;
40154 temp2 = true;
40155 }
40156 {
40157 PyThreadState* __tstate = wxPyBeginAllowThreads();
40158 (arg1)->SetHelpText((wxString const &)*arg2);
40159 wxPyEndAllowThreads(__tstate);
40160 if (PyErr_Occurred()) SWIG_fail;
40161 }
40162 resultobj = SWIG_Py_Void();
40163 {
40164 if (temp2)
40165 delete arg2;
40166 }
40167 return resultobj;
40168 fail:
40169 {
40170 if (temp2)
40171 delete arg2;
40172 }
40173 return NULL;
40174 }
40175
40176
40177 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40178 PyObject *resultobj = 0;
40179 wxWindow *arg1 = (wxWindow *) 0 ;
40180 wxString *arg2 = 0 ;
40181 void *argp1 = 0 ;
40182 int res1 = 0 ;
40183 bool temp2 = false ;
40184 PyObject * obj0 = 0 ;
40185 PyObject * obj1 = 0 ;
40186 char * kwnames[] = {
40187 (char *) "self",(char *) "text", NULL
40188 };
40189
40190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
40191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40192 if (!SWIG_IsOK(res1)) {
40193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
40194 }
40195 arg1 = reinterpret_cast< wxWindow * >(argp1);
40196 {
40197 arg2 = wxString_in_helper(obj1);
40198 if (arg2 == NULL) SWIG_fail;
40199 temp2 = true;
40200 }
40201 {
40202 PyThreadState* __tstate = wxPyBeginAllowThreads();
40203 (arg1)->SetHelpTextForId((wxString const &)*arg2);
40204 wxPyEndAllowThreads(__tstate);
40205 if (PyErr_Occurred()) SWIG_fail;
40206 }
40207 resultobj = SWIG_Py_Void();
40208 {
40209 if (temp2)
40210 delete arg2;
40211 }
40212 return resultobj;
40213 fail:
40214 {
40215 if (temp2)
40216 delete arg2;
40217 }
40218 return NULL;
40219 }
40220
40221
40222 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40223 PyObject *resultobj = 0;
40224 wxWindow *arg1 = (wxWindow *) 0 ;
40225 wxPoint *arg2 = 0 ;
40226 wxHelpEvent::Origin arg3 ;
40227 wxString result;
40228 void *argp1 = 0 ;
40229 int res1 = 0 ;
40230 wxPoint temp2 ;
40231 void *argp3 ;
40232 int res3 = 0 ;
40233 PyObject * obj0 = 0 ;
40234 PyObject * obj1 = 0 ;
40235 PyObject * obj2 = 0 ;
40236 char * kwnames[] = {
40237 (char *) "self",(char *) "pt",(char *) "origin", NULL
40238 };
40239
40240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40242 if (!SWIG_IsOK(res1)) {
40243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
40244 }
40245 arg1 = reinterpret_cast< wxWindow * >(argp1);
40246 {
40247 arg2 = &temp2;
40248 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40249 }
40250 {
40251 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
40252 if (!SWIG_IsOK(res3)) {
40253 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40254 }
40255 if (!argp3) {
40256 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40257 } else {
40258 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
40259 arg3 = *temp;
40260 if (SWIG_IsNewObj(res3)) delete temp;
40261 }
40262 }
40263 {
40264 PyThreadState* __tstate = wxPyBeginAllowThreads();
40265 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
40266 wxPyEndAllowThreads(__tstate);
40267 if (PyErr_Occurred()) SWIG_fail;
40268 }
40269 {
40270 #if wxUSE_UNICODE
40271 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40272 #else
40273 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40274 #endif
40275 }
40276 return resultobj;
40277 fail:
40278 return NULL;
40279 }
40280
40281
40282 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40283 PyObject *resultobj = 0;
40284 wxWindow *arg1 = (wxWindow *) 0 ;
40285 wxString result;
40286 void *argp1 = 0 ;
40287 int res1 = 0 ;
40288 PyObject *swig_obj[1] ;
40289
40290 if (!args) SWIG_fail;
40291 swig_obj[0] = args;
40292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40293 if (!SWIG_IsOK(res1)) {
40294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
40295 }
40296 arg1 = reinterpret_cast< wxWindow * >(argp1);
40297 {
40298 PyThreadState* __tstate = wxPyBeginAllowThreads();
40299 result = ((wxWindow const *)arg1)->GetHelpText();
40300 wxPyEndAllowThreads(__tstate);
40301 if (PyErr_Occurred()) SWIG_fail;
40302 }
40303 {
40304 #if wxUSE_UNICODE
40305 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40306 #else
40307 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40308 #endif
40309 }
40310 return resultobj;
40311 fail:
40312 return NULL;
40313 }
40314
40315
40316 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40317 PyObject *resultobj = 0;
40318 wxWindow *arg1 = (wxWindow *) 0 ;
40319 wxString *arg2 = 0 ;
40320 void *argp1 = 0 ;
40321 int res1 = 0 ;
40322 bool temp2 = false ;
40323 PyObject * obj0 = 0 ;
40324 PyObject * obj1 = 0 ;
40325 char * kwnames[] = {
40326 (char *) "self",(char *) "tip", NULL
40327 };
40328
40329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
40330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40331 if (!SWIG_IsOK(res1)) {
40332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
40333 }
40334 arg1 = reinterpret_cast< wxWindow * >(argp1);
40335 {
40336 arg2 = wxString_in_helper(obj1);
40337 if (arg2 == NULL) SWIG_fail;
40338 temp2 = true;
40339 }
40340 {
40341 PyThreadState* __tstate = wxPyBeginAllowThreads();
40342 (arg1)->SetToolTip((wxString const &)*arg2);
40343 wxPyEndAllowThreads(__tstate);
40344 if (PyErr_Occurred()) SWIG_fail;
40345 }
40346 resultobj = SWIG_Py_Void();
40347 {
40348 if (temp2)
40349 delete arg2;
40350 }
40351 return resultobj;
40352 fail:
40353 {
40354 if (temp2)
40355 delete arg2;
40356 }
40357 return NULL;
40358 }
40359
40360
40361 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40362 PyObject *resultobj = 0;
40363 wxWindow *arg1 = (wxWindow *) 0 ;
40364 wxToolTip *arg2 = (wxToolTip *) 0 ;
40365 void *argp1 = 0 ;
40366 int res1 = 0 ;
40367 int res2 = 0 ;
40368 PyObject * obj0 = 0 ;
40369 PyObject * obj1 = 0 ;
40370 char * kwnames[] = {
40371 (char *) "self",(char *) "tip", NULL
40372 };
40373
40374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
40375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40376 if (!SWIG_IsOK(res1)) {
40377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
40378 }
40379 arg1 = reinterpret_cast< wxWindow * >(argp1);
40380 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
40381 if (!SWIG_IsOK(res2)) {
40382 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
40383 }
40384 {
40385 PyThreadState* __tstate = wxPyBeginAllowThreads();
40386 (arg1)->SetToolTip(arg2);
40387 wxPyEndAllowThreads(__tstate);
40388 if (PyErr_Occurred()) SWIG_fail;
40389 }
40390 resultobj = SWIG_Py_Void();
40391 return resultobj;
40392 fail:
40393 return NULL;
40394 }
40395
40396
40397 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40398 PyObject *resultobj = 0;
40399 wxWindow *arg1 = (wxWindow *) 0 ;
40400 wxToolTip *result = 0 ;
40401 void *argp1 = 0 ;
40402 int res1 = 0 ;
40403 PyObject *swig_obj[1] ;
40404
40405 if (!args) SWIG_fail;
40406 swig_obj[0] = args;
40407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40408 if (!SWIG_IsOK(res1)) {
40409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
40410 }
40411 arg1 = reinterpret_cast< wxWindow * >(argp1);
40412 {
40413 PyThreadState* __tstate = wxPyBeginAllowThreads();
40414 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
40415 wxPyEndAllowThreads(__tstate);
40416 if (PyErr_Occurred()) SWIG_fail;
40417 }
40418 {
40419 resultobj = wxPyMake_wxObject(result, (bool)0);
40420 }
40421 return resultobj;
40422 fail:
40423 return NULL;
40424 }
40425
40426
40427 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40428 PyObject *resultobj = 0;
40429 wxWindow *arg1 = (wxWindow *) 0 ;
40430 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
40431 void *argp1 = 0 ;
40432 int res1 = 0 ;
40433 int res2 = 0 ;
40434 PyObject * obj0 = 0 ;
40435 PyObject * obj1 = 0 ;
40436 char * kwnames[] = {
40437 (char *) "self",(char *) "dropTarget", NULL
40438 };
40439
40440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
40441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40442 if (!SWIG_IsOK(res1)) {
40443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
40444 }
40445 arg1 = reinterpret_cast< wxWindow * >(argp1);
40446 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
40447 if (!SWIG_IsOK(res2)) {
40448 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
40449 }
40450 {
40451 PyThreadState* __tstate = wxPyBeginAllowThreads();
40452 (arg1)->SetDropTarget(arg2);
40453 wxPyEndAllowThreads(__tstate);
40454 if (PyErr_Occurred()) SWIG_fail;
40455 }
40456 resultobj = SWIG_Py_Void();
40457 return resultobj;
40458 fail:
40459 return NULL;
40460 }
40461
40462
40463 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40464 PyObject *resultobj = 0;
40465 wxWindow *arg1 = (wxWindow *) 0 ;
40466 wxPyDropTarget *result = 0 ;
40467 void *argp1 = 0 ;
40468 int res1 = 0 ;
40469 PyObject *swig_obj[1] ;
40470
40471 if (!args) SWIG_fail;
40472 swig_obj[0] = args;
40473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40474 if (!SWIG_IsOK(res1)) {
40475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
40476 }
40477 arg1 = reinterpret_cast< wxWindow * >(argp1);
40478 {
40479 PyThreadState* __tstate = wxPyBeginAllowThreads();
40480 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
40481 wxPyEndAllowThreads(__tstate);
40482 if (PyErr_Occurred()) SWIG_fail;
40483 }
40484 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
40485 return resultobj;
40486 fail:
40487 return NULL;
40488 }
40489
40490
40491 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40492 PyObject *resultobj = 0;
40493 wxWindow *arg1 = (wxWindow *) 0 ;
40494 bool arg2 ;
40495 void *argp1 = 0 ;
40496 int res1 = 0 ;
40497 bool val2 ;
40498 int ecode2 = 0 ;
40499 PyObject * obj0 = 0 ;
40500 PyObject * obj1 = 0 ;
40501 char * kwnames[] = {
40502 (char *) "self",(char *) "accept", NULL
40503 };
40504
40505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
40506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40507 if (!SWIG_IsOK(res1)) {
40508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
40509 }
40510 arg1 = reinterpret_cast< wxWindow * >(argp1);
40511 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40512 if (!SWIG_IsOK(ecode2)) {
40513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
40514 }
40515 arg2 = static_cast< bool >(val2);
40516 {
40517 PyThreadState* __tstate = wxPyBeginAllowThreads();
40518 wxWindow_DragAcceptFiles(arg1,arg2);
40519 wxPyEndAllowThreads(__tstate);
40520 if (PyErr_Occurred()) SWIG_fail;
40521 }
40522 resultobj = SWIG_Py_Void();
40523 return resultobj;
40524 fail:
40525 return NULL;
40526 }
40527
40528
40529 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40530 PyObject *resultobj = 0;
40531 wxWindow *arg1 = (wxWindow *) 0 ;
40532 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
40533 void *argp1 = 0 ;
40534 int res1 = 0 ;
40535 int res2 = 0 ;
40536 PyObject * obj0 = 0 ;
40537 PyObject * obj1 = 0 ;
40538 char * kwnames[] = {
40539 (char *) "self",(char *) "constraints", NULL
40540 };
40541
40542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
40543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40544 if (!SWIG_IsOK(res1)) {
40545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
40546 }
40547 arg1 = reinterpret_cast< wxWindow * >(argp1);
40548 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
40549 if (!SWIG_IsOK(res2)) {
40550 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
40551 }
40552 {
40553 PyThreadState* __tstate = wxPyBeginAllowThreads();
40554 (arg1)->SetConstraints(arg2);
40555 wxPyEndAllowThreads(__tstate);
40556 if (PyErr_Occurred()) SWIG_fail;
40557 }
40558 resultobj = SWIG_Py_Void();
40559 return resultobj;
40560 fail:
40561 return NULL;
40562 }
40563
40564
40565 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40566 PyObject *resultobj = 0;
40567 wxWindow *arg1 = (wxWindow *) 0 ;
40568 wxLayoutConstraints *result = 0 ;
40569 void *argp1 = 0 ;
40570 int res1 = 0 ;
40571 PyObject *swig_obj[1] ;
40572
40573 if (!args) SWIG_fail;
40574 swig_obj[0] = args;
40575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40576 if (!SWIG_IsOK(res1)) {
40577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
40578 }
40579 arg1 = reinterpret_cast< wxWindow * >(argp1);
40580 {
40581 PyThreadState* __tstate = wxPyBeginAllowThreads();
40582 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
40583 wxPyEndAllowThreads(__tstate);
40584 if (PyErr_Occurred()) SWIG_fail;
40585 }
40586 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
40587 return resultobj;
40588 fail:
40589 return NULL;
40590 }
40591
40592
40593 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40594 PyObject *resultobj = 0;
40595 wxWindow *arg1 = (wxWindow *) 0 ;
40596 bool arg2 ;
40597 void *argp1 = 0 ;
40598 int res1 = 0 ;
40599 bool val2 ;
40600 int ecode2 = 0 ;
40601 PyObject * obj0 = 0 ;
40602 PyObject * obj1 = 0 ;
40603 char * kwnames[] = {
40604 (char *) "self",(char *) "autoLayout", NULL
40605 };
40606
40607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
40608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40609 if (!SWIG_IsOK(res1)) {
40610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
40611 }
40612 arg1 = reinterpret_cast< wxWindow * >(argp1);
40613 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40614 if (!SWIG_IsOK(ecode2)) {
40615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
40616 }
40617 arg2 = static_cast< bool >(val2);
40618 {
40619 PyThreadState* __tstate = wxPyBeginAllowThreads();
40620 (arg1)->SetAutoLayout(arg2);
40621 wxPyEndAllowThreads(__tstate);
40622 if (PyErr_Occurred()) SWIG_fail;
40623 }
40624 resultobj = SWIG_Py_Void();
40625 return resultobj;
40626 fail:
40627 return NULL;
40628 }
40629
40630
40631 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40632 PyObject *resultobj = 0;
40633 wxWindow *arg1 = (wxWindow *) 0 ;
40634 bool result;
40635 void *argp1 = 0 ;
40636 int res1 = 0 ;
40637 PyObject *swig_obj[1] ;
40638
40639 if (!args) SWIG_fail;
40640 swig_obj[0] = args;
40641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40642 if (!SWIG_IsOK(res1)) {
40643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
40644 }
40645 arg1 = reinterpret_cast< wxWindow * >(argp1);
40646 {
40647 PyThreadState* __tstate = wxPyBeginAllowThreads();
40648 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
40649 wxPyEndAllowThreads(__tstate);
40650 if (PyErr_Occurred()) SWIG_fail;
40651 }
40652 {
40653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40654 }
40655 return resultobj;
40656 fail:
40657 return NULL;
40658 }
40659
40660
40661 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40662 PyObject *resultobj = 0;
40663 wxWindow *arg1 = (wxWindow *) 0 ;
40664 bool result;
40665 void *argp1 = 0 ;
40666 int res1 = 0 ;
40667 PyObject *swig_obj[1] ;
40668
40669 if (!args) SWIG_fail;
40670 swig_obj[0] = args;
40671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40672 if (!SWIG_IsOK(res1)) {
40673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
40674 }
40675 arg1 = reinterpret_cast< wxWindow * >(argp1);
40676 {
40677 PyThreadState* __tstate = wxPyBeginAllowThreads();
40678 result = (bool)(arg1)->Layout();
40679 wxPyEndAllowThreads(__tstate);
40680 if (PyErr_Occurred()) SWIG_fail;
40681 }
40682 {
40683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40684 }
40685 return resultobj;
40686 fail:
40687 return NULL;
40688 }
40689
40690
40691 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40692 PyObject *resultobj = 0;
40693 wxWindow *arg1 = (wxWindow *) 0 ;
40694 wxSizer *arg2 = (wxSizer *) 0 ;
40695 bool arg3 = (bool) true ;
40696 void *argp1 = 0 ;
40697 int res1 = 0 ;
40698 int res2 = 0 ;
40699 bool val3 ;
40700 int ecode3 = 0 ;
40701 PyObject * obj0 = 0 ;
40702 PyObject * obj1 = 0 ;
40703 PyObject * obj2 = 0 ;
40704 char * kwnames[] = {
40705 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40706 };
40707
40708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40710 if (!SWIG_IsOK(res1)) {
40711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40712 }
40713 arg1 = reinterpret_cast< wxWindow * >(argp1);
40714 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40715 if (!SWIG_IsOK(res2)) {
40716 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40717 }
40718 if (obj2) {
40719 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40720 if (!SWIG_IsOK(ecode3)) {
40721 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
40722 }
40723 arg3 = static_cast< bool >(val3);
40724 }
40725 {
40726 PyThreadState* __tstate = wxPyBeginAllowThreads();
40727 (arg1)->SetSizer(arg2,arg3);
40728 wxPyEndAllowThreads(__tstate);
40729 if (PyErr_Occurred()) SWIG_fail;
40730 }
40731 resultobj = SWIG_Py_Void();
40732 return resultobj;
40733 fail:
40734 return NULL;
40735 }
40736
40737
40738 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40739 PyObject *resultobj = 0;
40740 wxWindow *arg1 = (wxWindow *) 0 ;
40741 wxSizer *arg2 = (wxSizer *) 0 ;
40742 bool arg3 = (bool) true ;
40743 void *argp1 = 0 ;
40744 int res1 = 0 ;
40745 int res2 = 0 ;
40746 bool val3 ;
40747 int ecode3 = 0 ;
40748 PyObject * obj0 = 0 ;
40749 PyObject * obj1 = 0 ;
40750 PyObject * obj2 = 0 ;
40751 char * kwnames[] = {
40752 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40753 };
40754
40755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40757 if (!SWIG_IsOK(res1)) {
40758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
40759 }
40760 arg1 = reinterpret_cast< wxWindow * >(argp1);
40761 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40762 if (!SWIG_IsOK(res2)) {
40763 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
40764 }
40765 if (obj2) {
40766 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40767 if (!SWIG_IsOK(ecode3)) {
40768 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
40769 }
40770 arg3 = static_cast< bool >(val3);
40771 }
40772 {
40773 PyThreadState* __tstate = wxPyBeginAllowThreads();
40774 (arg1)->SetSizerAndFit(arg2,arg3);
40775 wxPyEndAllowThreads(__tstate);
40776 if (PyErr_Occurred()) SWIG_fail;
40777 }
40778 resultobj = SWIG_Py_Void();
40779 return resultobj;
40780 fail:
40781 return NULL;
40782 }
40783
40784
40785 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40786 PyObject *resultobj = 0;
40787 wxWindow *arg1 = (wxWindow *) 0 ;
40788 wxSizer *result = 0 ;
40789 void *argp1 = 0 ;
40790 int res1 = 0 ;
40791 PyObject *swig_obj[1] ;
40792
40793 if (!args) SWIG_fail;
40794 swig_obj[0] = args;
40795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40796 if (!SWIG_IsOK(res1)) {
40797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
40798 }
40799 arg1 = reinterpret_cast< wxWindow * >(argp1);
40800 {
40801 PyThreadState* __tstate = wxPyBeginAllowThreads();
40802 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
40803 wxPyEndAllowThreads(__tstate);
40804 if (PyErr_Occurred()) SWIG_fail;
40805 }
40806 {
40807 resultobj = wxPyMake_wxObject(result, (bool)0);
40808 }
40809 return resultobj;
40810 fail:
40811 return NULL;
40812 }
40813
40814
40815 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40816 PyObject *resultobj = 0;
40817 wxWindow *arg1 = (wxWindow *) 0 ;
40818 wxSizer *arg2 = (wxSizer *) 0 ;
40819 void *argp1 = 0 ;
40820 int res1 = 0 ;
40821 void *argp2 = 0 ;
40822 int res2 = 0 ;
40823 PyObject * obj0 = 0 ;
40824 PyObject * obj1 = 0 ;
40825 char * kwnames[] = {
40826 (char *) "self",(char *) "sizer", NULL
40827 };
40828
40829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
40830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40831 if (!SWIG_IsOK(res1)) {
40832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40833 }
40834 arg1 = reinterpret_cast< wxWindow * >(argp1);
40835 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
40836 if (!SWIG_IsOK(res2)) {
40837 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40838 }
40839 arg2 = reinterpret_cast< wxSizer * >(argp2);
40840 {
40841 PyThreadState* __tstate = wxPyBeginAllowThreads();
40842 (arg1)->SetContainingSizer(arg2);
40843 wxPyEndAllowThreads(__tstate);
40844 if (PyErr_Occurred()) SWIG_fail;
40845 }
40846 resultobj = SWIG_Py_Void();
40847 return resultobj;
40848 fail:
40849 return NULL;
40850 }
40851
40852
40853 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40854 PyObject *resultobj = 0;
40855 wxWindow *arg1 = (wxWindow *) 0 ;
40856 wxSizer *result = 0 ;
40857 void *argp1 = 0 ;
40858 int res1 = 0 ;
40859 PyObject *swig_obj[1] ;
40860
40861 if (!args) SWIG_fail;
40862 swig_obj[0] = args;
40863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40864 if (!SWIG_IsOK(res1)) {
40865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
40866 }
40867 arg1 = reinterpret_cast< wxWindow * >(argp1);
40868 {
40869 PyThreadState* __tstate = wxPyBeginAllowThreads();
40870 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
40871 wxPyEndAllowThreads(__tstate);
40872 if (PyErr_Occurred()) SWIG_fail;
40873 }
40874 {
40875 resultobj = wxPyMake_wxObject(result, (bool)0);
40876 }
40877 return resultobj;
40878 fail:
40879 return NULL;
40880 }
40881
40882
40883 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40884 PyObject *resultobj = 0;
40885 wxWindow *arg1 = (wxWindow *) 0 ;
40886 void *argp1 = 0 ;
40887 int res1 = 0 ;
40888 PyObject *swig_obj[1] ;
40889
40890 if (!args) SWIG_fail;
40891 swig_obj[0] = args;
40892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40893 if (!SWIG_IsOK(res1)) {
40894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
40895 }
40896 arg1 = reinterpret_cast< wxWindow * >(argp1);
40897 {
40898 PyThreadState* __tstate = wxPyBeginAllowThreads();
40899 (arg1)->InheritAttributes();
40900 wxPyEndAllowThreads(__tstate);
40901 if (PyErr_Occurred()) SWIG_fail;
40902 }
40903 resultobj = SWIG_Py_Void();
40904 return resultobj;
40905 fail:
40906 return NULL;
40907 }
40908
40909
40910 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40911 PyObject *resultobj = 0;
40912 wxWindow *arg1 = (wxWindow *) 0 ;
40913 bool result;
40914 void *argp1 = 0 ;
40915 int res1 = 0 ;
40916 PyObject *swig_obj[1] ;
40917
40918 if (!args) SWIG_fail;
40919 swig_obj[0] = args;
40920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40921 if (!SWIG_IsOK(res1)) {
40922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
40923 }
40924 arg1 = reinterpret_cast< wxWindow * >(argp1);
40925 {
40926 PyThreadState* __tstate = wxPyBeginAllowThreads();
40927 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
40928 wxPyEndAllowThreads(__tstate);
40929 if (PyErr_Occurred()) SWIG_fail;
40930 }
40931 {
40932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40933 }
40934 return resultobj;
40935 fail:
40936 return NULL;
40937 }
40938
40939
40940 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40941 PyObject *resultobj = 0;
40942 wxWindow *arg1 = (wxWindow *) 0 ;
40943 bool result;
40944 void *argp1 = 0 ;
40945 int res1 = 0 ;
40946 PyObject *swig_obj[1] ;
40947
40948 if (!args) SWIG_fail;
40949 swig_obj[0] = args;
40950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40951 if (!SWIG_IsOK(res1)) {
40952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
40953 }
40954 arg1 = reinterpret_cast< wxWindow * >(argp1);
40955 {
40956 PyThreadState* __tstate = wxPyBeginAllowThreads();
40957 result = (bool)(arg1)->CanSetTransparent();
40958 wxPyEndAllowThreads(__tstate);
40959 if (PyErr_Occurred()) SWIG_fail;
40960 }
40961 {
40962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40963 }
40964 return resultobj;
40965 fail:
40966 return NULL;
40967 }
40968
40969
40970 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40971 PyObject *resultobj = 0;
40972 wxWindow *arg1 = (wxWindow *) 0 ;
40973 byte arg2 ;
40974 bool result;
40975 void *argp1 = 0 ;
40976 int res1 = 0 ;
40977 unsigned char val2 ;
40978 int ecode2 = 0 ;
40979 PyObject * obj0 = 0 ;
40980 PyObject * obj1 = 0 ;
40981 char * kwnames[] = {
40982 (char *) "self",(char *) "alpha", NULL
40983 };
40984
40985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
40986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40987 if (!SWIG_IsOK(res1)) {
40988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
40989 }
40990 arg1 = reinterpret_cast< wxWindow * >(argp1);
40991 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
40992 if (!SWIG_IsOK(ecode2)) {
40993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
40994 }
40995 arg2 = static_cast< byte >(val2);
40996 {
40997 PyThreadState* __tstate = wxPyBeginAllowThreads();
40998 result = (bool)(arg1)->SetTransparent(arg2);
40999 wxPyEndAllowThreads(__tstate);
41000 if (PyErr_Occurred()) SWIG_fail;
41001 }
41002 {
41003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41004 }
41005 return resultobj;
41006 fail:
41007 return NULL;
41008 }
41009
41010
41011 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41012 PyObject *obj;
41013 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41014 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
41015 return SWIG_Py_Void();
41016 }
41017
41018 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41019 return SWIG_Python_InitShadowInstance(args);
41020 }
41021
41022 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41023 PyObject *resultobj = 0;
41024 long arg1 ;
41025 wxWindow *arg2 = (wxWindow *) NULL ;
41026 wxWindow *result = 0 ;
41027 long val1 ;
41028 int ecode1 = 0 ;
41029 void *argp2 = 0 ;
41030 int res2 = 0 ;
41031 PyObject * obj0 = 0 ;
41032 PyObject * obj1 = 0 ;
41033 char * kwnames[] = {
41034 (char *) "id",(char *) "parent", NULL
41035 };
41036
41037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
41038 ecode1 = SWIG_AsVal_long(obj0, &val1);
41039 if (!SWIG_IsOK(ecode1)) {
41040 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
41041 }
41042 arg1 = static_cast< long >(val1);
41043 if (obj1) {
41044 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41045 if (!SWIG_IsOK(res2)) {
41046 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
41047 }
41048 arg2 = reinterpret_cast< wxWindow * >(argp2);
41049 }
41050 {
41051 if (!wxPyCheckForApp()) SWIG_fail;
41052 PyThreadState* __tstate = wxPyBeginAllowThreads();
41053 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
41054 wxPyEndAllowThreads(__tstate);
41055 if (PyErr_Occurred()) SWIG_fail;
41056 }
41057 {
41058 resultobj = wxPyMake_wxObject(result, 0);
41059 }
41060 return resultobj;
41061 fail:
41062 return NULL;
41063 }
41064
41065
41066 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41067 PyObject *resultobj = 0;
41068 wxString *arg1 = 0 ;
41069 wxWindow *arg2 = (wxWindow *) NULL ;
41070 wxWindow *result = 0 ;
41071 bool temp1 = false ;
41072 void *argp2 = 0 ;
41073 int res2 = 0 ;
41074 PyObject * obj0 = 0 ;
41075 PyObject * obj1 = 0 ;
41076 char * kwnames[] = {
41077 (char *) "name",(char *) "parent", NULL
41078 };
41079
41080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
41081 {
41082 arg1 = wxString_in_helper(obj0);
41083 if (arg1 == NULL) SWIG_fail;
41084 temp1 = true;
41085 }
41086 if (obj1) {
41087 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41088 if (!SWIG_IsOK(res2)) {
41089 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
41090 }
41091 arg2 = reinterpret_cast< wxWindow * >(argp2);
41092 }
41093 {
41094 if (!wxPyCheckForApp()) SWIG_fail;
41095 PyThreadState* __tstate = wxPyBeginAllowThreads();
41096 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
41097 wxPyEndAllowThreads(__tstate);
41098 if (PyErr_Occurred()) SWIG_fail;
41099 }
41100 {
41101 resultobj = wxPyMake_wxObject(result, 0);
41102 }
41103 {
41104 if (temp1)
41105 delete arg1;
41106 }
41107 return resultobj;
41108 fail:
41109 {
41110 if (temp1)
41111 delete arg1;
41112 }
41113 return NULL;
41114 }
41115
41116
41117 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41118 PyObject *resultobj = 0;
41119 wxString *arg1 = 0 ;
41120 wxWindow *arg2 = (wxWindow *) NULL ;
41121 wxWindow *result = 0 ;
41122 bool temp1 = false ;
41123 void *argp2 = 0 ;
41124 int res2 = 0 ;
41125 PyObject * obj0 = 0 ;
41126 PyObject * obj1 = 0 ;
41127 char * kwnames[] = {
41128 (char *) "label",(char *) "parent", NULL
41129 };
41130
41131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41132 {
41133 arg1 = wxString_in_helper(obj0);
41134 if (arg1 == NULL) SWIG_fail;
41135 temp1 = true;
41136 }
41137 if (obj1) {
41138 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41139 if (!SWIG_IsOK(res2)) {
41140 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
41141 }
41142 arg2 = reinterpret_cast< wxWindow * >(argp2);
41143 }
41144 {
41145 if (!wxPyCheckForApp()) SWIG_fail;
41146 PyThreadState* __tstate = wxPyBeginAllowThreads();
41147 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
41148 wxPyEndAllowThreads(__tstate);
41149 if (PyErr_Occurred()) SWIG_fail;
41150 }
41151 {
41152 resultobj = wxPyMake_wxObject(result, 0);
41153 }
41154 {
41155 if (temp1)
41156 delete arg1;
41157 }
41158 return resultobj;
41159 fail:
41160 {
41161 if (temp1)
41162 delete arg1;
41163 }
41164 return NULL;
41165 }
41166
41167
41168 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41169 PyObject *resultobj = 0;
41170 wxWindow *arg1 = (wxWindow *) 0 ;
41171 unsigned long arg2 ;
41172 wxWindow *result = 0 ;
41173 void *argp1 = 0 ;
41174 int res1 = 0 ;
41175 unsigned long val2 ;
41176 int ecode2 = 0 ;
41177 PyObject * obj0 = 0 ;
41178 PyObject * obj1 = 0 ;
41179 char * kwnames[] = {
41180 (char *) "parent",(char *) "_hWnd", NULL
41181 };
41182
41183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
41184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41185 if (!SWIG_IsOK(res1)) {
41186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
41187 }
41188 arg1 = reinterpret_cast< wxWindow * >(argp1);
41189 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
41190 if (!SWIG_IsOK(ecode2)) {
41191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
41192 }
41193 arg2 = static_cast< unsigned long >(val2);
41194 {
41195 PyThreadState* __tstate = wxPyBeginAllowThreads();
41196 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
41197 wxPyEndAllowThreads(__tstate);
41198 if (PyErr_Occurred()) SWIG_fail;
41199 }
41200 {
41201 resultobj = wxPyMake_wxObject(result, 0);
41202 }
41203 return resultobj;
41204 fail:
41205 return NULL;
41206 }
41207
41208
41209 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41210 PyObject *resultobj = 0;
41211 PyObject *result = 0 ;
41212
41213 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
41214 {
41215 PyThreadState* __tstate = wxPyBeginAllowThreads();
41216 result = (PyObject *)GetTopLevelWindows();
41217 wxPyEndAllowThreads(__tstate);
41218 if (PyErr_Occurred()) SWIG_fail;
41219 }
41220 resultobj = result;
41221 return resultobj;
41222 fail:
41223 return NULL;
41224 }
41225
41226
41227 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41228 PyObject *resultobj = 0;
41229 wxValidator *result = 0 ;
41230
41231 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
41232 {
41233 PyThreadState* __tstate = wxPyBeginAllowThreads();
41234 result = (wxValidator *)new wxValidator();
41235 wxPyEndAllowThreads(__tstate);
41236 if (PyErr_Occurred()) SWIG_fail;
41237 }
41238 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
41239 return resultobj;
41240 fail:
41241 return NULL;
41242 }
41243
41244
41245 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41246 PyObject *resultobj = 0;
41247 wxValidator *arg1 = (wxValidator *) 0 ;
41248 wxValidator *result = 0 ;
41249 void *argp1 = 0 ;
41250 int res1 = 0 ;
41251 PyObject *swig_obj[1] ;
41252
41253 if (!args) SWIG_fail;
41254 swig_obj[0] = args;
41255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41256 if (!SWIG_IsOK(res1)) {
41257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
41258 }
41259 arg1 = reinterpret_cast< wxValidator * >(argp1);
41260 {
41261 PyThreadState* __tstate = wxPyBeginAllowThreads();
41262 result = (wxValidator *)(arg1)->Clone();
41263 wxPyEndAllowThreads(__tstate);
41264 if (PyErr_Occurred()) SWIG_fail;
41265 }
41266 {
41267 resultobj = wxPyMake_wxObject(result, 0);
41268 }
41269 return resultobj;
41270 fail:
41271 return NULL;
41272 }
41273
41274
41275 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41276 PyObject *resultobj = 0;
41277 wxValidator *arg1 = (wxValidator *) 0 ;
41278 wxWindow *arg2 = (wxWindow *) 0 ;
41279 bool result;
41280 void *argp1 = 0 ;
41281 int res1 = 0 ;
41282 void *argp2 = 0 ;
41283 int res2 = 0 ;
41284 PyObject * obj0 = 0 ;
41285 PyObject * obj1 = 0 ;
41286 char * kwnames[] = {
41287 (char *) "self",(char *) "parent", NULL
41288 };
41289
41290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
41291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41292 if (!SWIG_IsOK(res1)) {
41293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
41294 }
41295 arg1 = reinterpret_cast< wxValidator * >(argp1);
41296 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41297 if (!SWIG_IsOK(res2)) {
41298 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
41299 }
41300 arg2 = reinterpret_cast< wxWindow * >(argp2);
41301 {
41302 PyThreadState* __tstate = wxPyBeginAllowThreads();
41303 result = (bool)(arg1)->Validate(arg2);
41304 wxPyEndAllowThreads(__tstate);
41305 if (PyErr_Occurred()) SWIG_fail;
41306 }
41307 {
41308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41309 }
41310 return resultobj;
41311 fail:
41312 return NULL;
41313 }
41314
41315
41316 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41317 PyObject *resultobj = 0;
41318 wxValidator *arg1 = (wxValidator *) 0 ;
41319 bool result;
41320 void *argp1 = 0 ;
41321 int res1 = 0 ;
41322 PyObject *swig_obj[1] ;
41323
41324 if (!args) SWIG_fail;
41325 swig_obj[0] = args;
41326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41327 if (!SWIG_IsOK(res1)) {
41328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41329 }
41330 arg1 = reinterpret_cast< wxValidator * >(argp1);
41331 {
41332 PyThreadState* __tstate = wxPyBeginAllowThreads();
41333 result = (bool)(arg1)->TransferToWindow();
41334 wxPyEndAllowThreads(__tstate);
41335 if (PyErr_Occurred()) SWIG_fail;
41336 }
41337 {
41338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41339 }
41340 return resultobj;
41341 fail:
41342 return NULL;
41343 }
41344
41345
41346 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41347 PyObject *resultobj = 0;
41348 wxValidator *arg1 = (wxValidator *) 0 ;
41349 bool result;
41350 void *argp1 = 0 ;
41351 int res1 = 0 ;
41352 PyObject *swig_obj[1] ;
41353
41354 if (!args) SWIG_fail;
41355 swig_obj[0] = args;
41356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41357 if (!SWIG_IsOK(res1)) {
41358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41359 }
41360 arg1 = reinterpret_cast< wxValidator * >(argp1);
41361 {
41362 PyThreadState* __tstate = wxPyBeginAllowThreads();
41363 result = (bool)(arg1)->TransferFromWindow();
41364 wxPyEndAllowThreads(__tstate);
41365 if (PyErr_Occurred()) SWIG_fail;
41366 }
41367 {
41368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41369 }
41370 return resultobj;
41371 fail:
41372 return NULL;
41373 }
41374
41375
41376 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41377 PyObject *resultobj = 0;
41378 wxValidator *arg1 = (wxValidator *) 0 ;
41379 wxWindow *result = 0 ;
41380 void *argp1 = 0 ;
41381 int res1 = 0 ;
41382 PyObject *swig_obj[1] ;
41383
41384 if (!args) SWIG_fail;
41385 swig_obj[0] = args;
41386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41387 if (!SWIG_IsOK(res1)) {
41388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41389 }
41390 arg1 = reinterpret_cast< wxValidator * >(argp1);
41391 {
41392 PyThreadState* __tstate = wxPyBeginAllowThreads();
41393 result = (wxWindow *)(arg1)->GetWindow();
41394 wxPyEndAllowThreads(__tstate);
41395 if (PyErr_Occurred()) SWIG_fail;
41396 }
41397 {
41398 resultobj = wxPyMake_wxObject(result, 0);
41399 }
41400 return resultobj;
41401 fail:
41402 return NULL;
41403 }
41404
41405
41406 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41407 PyObject *resultobj = 0;
41408 wxValidator *arg1 = (wxValidator *) 0 ;
41409 wxWindow *arg2 = (wxWindow *) 0 ;
41410 void *argp1 = 0 ;
41411 int res1 = 0 ;
41412 void *argp2 = 0 ;
41413 int res2 = 0 ;
41414 PyObject * obj0 = 0 ;
41415 PyObject * obj1 = 0 ;
41416 char * kwnames[] = {
41417 (char *) "self",(char *) "window", NULL
41418 };
41419
41420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41422 if (!SWIG_IsOK(res1)) {
41423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41424 }
41425 arg1 = reinterpret_cast< wxValidator * >(argp1);
41426 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41427 if (!SWIG_IsOK(res2)) {
41428 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41429 }
41430 arg2 = reinterpret_cast< wxWindow * >(argp2);
41431 {
41432 PyThreadState* __tstate = wxPyBeginAllowThreads();
41433 (arg1)->SetWindow(arg2);
41434 wxPyEndAllowThreads(__tstate);
41435 if (PyErr_Occurred()) SWIG_fail;
41436 }
41437 resultobj = SWIG_Py_Void();
41438 return resultobj;
41439 fail:
41440 return NULL;
41441 }
41442
41443
41444 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41445 PyObject *resultobj = 0;
41446 bool result;
41447
41448 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
41449 {
41450 PyThreadState* __tstate = wxPyBeginAllowThreads();
41451 result = (bool)wxValidator::IsSilent();
41452 wxPyEndAllowThreads(__tstate);
41453 if (PyErr_Occurred()) SWIG_fail;
41454 }
41455 {
41456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41457 }
41458 return resultobj;
41459 fail:
41460 return NULL;
41461 }
41462
41463
41464 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41465 PyObject *resultobj = 0;
41466 int arg1 = (int) true ;
41467 int val1 ;
41468 int ecode1 = 0 ;
41469 PyObject * obj0 = 0 ;
41470 char * kwnames[] = {
41471 (char *) "doIt", NULL
41472 };
41473
41474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
41475 if (obj0) {
41476 ecode1 = SWIG_AsVal_int(obj0, &val1);
41477 if (!SWIG_IsOK(ecode1)) {
41478 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
41479 }
41480 arg1 = static_cast< int >(val1);
41481 }
41482 {
41483 PyThreadState* __tstate = wxPyBeginAllowThreads();
41484 wxValidator::SetBellOnError(arg1);
41485 wxPyEndAllowThreads(__tstate);
41486 if (PyErr_Occurred()) SWIG_fail;
41487 }
41488 resultobj = SWIG_Py_Void();
41489 return resultobj;
41490 fail:
41491 return NULL;
41492 }
41493
41494
41495 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41496 PyObject *obj;
41497 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41498 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
41499 return SWIG_Py_Void();
41500 }
41501
41502 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41503 return SWIG_Python_InitShadowInstance(args);
41504 }
41505
41506 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41507 PyObject *resultobj = 0;
41508 wxPyValidator *result = 0 ;
41509
41510 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
41511 {
41512 PyThreadState* __tstate = wxPyBeginAllowThreads();
41513 result = (wxPyValidator *)new wxPyValidator();
41514 wxPyEndAllowThreads(__tstate);
41515 if (PyErr_Occurred()) SWIG_fail;
41516 }
41517 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
41518 return resultobj;
41519 fail:
41520 return NULL;
41521 }
41522
41523
41524 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41525 PyObject *resultobj = 0;
41526 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
41527 PyObject *arg2 = (PyObject *) 0 ;
41528 PyObject *arg3 = (PyObject *) 0 ;
41529 int arg4 = (int) 1 ;
41530 void *argp1 = 0 ;
41531 int res1 = 0 ;
41532 int val4 ;
41533 int ecode4 = 0 ;
41534 PyObject * obj0 = 0 ;
41535 PyObject * obj1 = 0 ;
41536 PyObject * obj2 = 0 ;
41537 PyObject * obj3 = 0 ;
41538 char * kwnames[] = {
41539 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
41540 };
41541
41542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
41544 if (!SWIG_IsOK(res1)) {
41545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
41546 }
41547 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
41548 arg2 = obj1;
41549 arg3 = obj2;
41550 if (obj3) {
41551 ecode4 = SWIG_AsVal_int(obj3, &val4);
41552 if (!SWIG_IsOK(ecode4)) {
41553 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
41554 }
41555 arg4 = static_cast< int >(val4);
41556 }
41557 {
41558 PyThreadState* __tstate = wxPyBeginAllowThreads();
41559 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
41560 wxPyEndAllowThreads(__tstate);
41561 if (PyErr_Occurred()) SWIG_fail;
41562 }
41563 resultobj = SWIG_Py_Void();
41564 return resultobj;
41565 fail:
41566 return NULL;
41567 }
41568
41569
41570 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41571 PyObject *obj;
41572 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41573 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
41574 return SWIG_Py_Void();
41575 }
41576
41577 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41578 return SWIG_Python_InitShadowInstance(args);
41579 }
41580
41581 SWIGINTERN int DefaultValidator_set(PyObject *) {
41582 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
41583 return 1;
41584 }
41585
41586
41587 SWIGINTERN PyObject *DefaultValidator_get(void) {
41588 PyObject *pyobj = 0;
41589
41590 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
41591 return pyobj;
41592 }
41593
41594
41595 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41596 PyObject *resultobj = 0;
41597 wxString const &arg1_defvalue = wxPyEmptyString ;
41598 wxString *arg1 = (wxString *) &arg1_defvalue ;
41599 long arg2 = (long) 0 ;
41600 wxMenu *result = 0 ;
41601 bool temp1 = false ;
41602 long val2 ;
41603 int ecode2 = 0 ;
41604 PyObject * obj0 = 0 ;
41605 PyObject * obj1 = 0 ;
41606 char * kwnames[] = {
41607 (char *) "title",(char *) "style", NULL
41608 };
41609
41610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
41611 if (obj0) {
41612 {
41613 arg1 = wxString_in_helper(obj0);
41614 if (arg1 == NULL) SWIG_fail;
41615 temp1 = true;
41616 }
41617 }
41618 if (obj1) {
41619 ecode2 = SWIG_AsVal_long(obj1, &val2);
41620 if (!SWIG_IsOK(ecode2)) {
41621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
41622 }
41623 arg2 = static_cast< long >(val2);
41624 }
41625 {
41626 if (!wxPyCheckForApp()) SWIG_fail;
41627 PyThreadState* __tstate = wxPyBeginAllowThreads();
41628 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
41629 wxPyEndAllowThreads(__tstate);
41630 if (PyErr_Occurred()) SWIG_fail;
41631 }
41632 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
41633 {
41634 if (temp1)
41635 delete arg1;
41636 }
41637 return resultobj;
41638 fail:
41639 {
41640 if (temp1)
41641 delete arg1;
41642 }
41643 return NULL;
41644 }
41645
41646
41647 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41648 PyObject *resultobj = 0;
41649 wxMenu *arg1 = (wxMenu *) 0 ;
41650 int arg2 ;
41651 wxString const &arg3_defvalue = wxPyEmptyString ;
41652 wxString *arg3 = (wxString *) &arg3_defvalue ;
41653 wxString const &arg4_defvalue = wxPyEmptyString ;
41654 wxString *arg4 = (wxString *) &arg4_defvalue ;
41655 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
41656 wxMenuItem *result = 0 ;
41657 void *argp1 = 0 ;
41658 int res1 = 0 ;
41659 int val2 ;
41660 int ecode2 = 0 ;
41661 bool temp3 = false ;
41662 bool temp4 = false ;
41663 int val5 ;
41664 int ecode5 = 0 ;
41665 PyObject * obj0 = 0 ;
41666 PyObject * obj1 = 0 ;
41667 PyObject * obj2 = 0 ;
41668 PyObject * obj3 = 0 ;
41669 PyObject * obj4 = 0 ;
41670 char * kwnames[] = {
41671 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
41672 };
41673
41674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
41675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41676 if (!SWIG_IsOK(res1)) {
41677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
41678 }
41679 arg1 = reinterpret_cast< wxMenu * >(argp1);
41680 ecode2 = SWIG_AsVal_int(obj1, &val2);
41681 if (!SWIG_IsOK(ecode2)) {
41682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
41683 }
41684 arg2 = static_cast< int >(val2);
41685 if (obj2) {
41686 {
41687 arg3 = wxString_in_helper(obj2);
41688 if (arg3 == NULL) SWIG_fail;
41689 temp3 = true;
41690 }
41691 }
41692 if (obj3) {
41693 {
41694 arg4 = wxString_in_helper(obj3);
41695 if (arg4 == NULL) SWIG_fail;
41696 temp4 = true;
41697 }
41698 }
41699 if (obj4) {
41700 ecode5 = SWIG_AsVal_int(obj4, &val5);
41701 if (!SWIG_IsOK(ecode5)) {
41702 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
41703 }
41704 arg5 = static_cast< wxItemKind >(val5);
41705 }
41706 {
41707 PyThreadState* __tstate = wxPyBeginAllowThreads();
41708 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
41709 wxPyEndAllowThreads(__tstate);
41710 if (PyErr_Occurred()) SWIG_fail;
41711 }
41712 {
41713 resultobj = wxPyMake_wxObject(result, (bool)0);
41714 }
41715 {
41716 if (temp3)
41717 delete arg3;
41718 }
41719 {
41720 if (temp4)
41721 delete arg4;
41722 }
41723 return resultobj;
41724 fail:
41725 {
41726 if (temp3)
41727 delete arg3;
41728 }
41729 {
41730 if (temp4)
41731 delete arg4;
41732 }
41733 return NULL;
41734 }
41735
41736
41737 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41738 PyObject *resultobj = 0;
41739 wxMenu *arg1 = (wxMenu *) 0 ;
41740 wxMenuItem *result = 0 ;
41741 void *argp1 = 0 ;
41742 int res1 = 0 ;
41743 PyObject *swig_obj[1] ;
41744
41745 if (!args) SWIG_fail;
41746 swig_obj[0] = args;
41747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41748 if (!SWIG_IsOK(res1)) {
41749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
41750 }
41751 arg1 = reinterpret_cast< wxMenu * >(argp1);
41752 {
41753 PyThreadState* __tstate = wxPyBeginAllowThreads();
41754 result = (wxMenuItem *)(arg1)->AppendSeparator();
41755 wxPyEndAllowThreads(__tstate);
41756 if (PyErr_Occurred()) SWIG_fail;
41757 }
41758 {
41759 resultobj = wxPyMake_wxObject(result, (bool)0);
41760 }
41761 return resultobj;
41762 fail:
41763 return NULL;
41764 }
41765
41766
41767 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41768 PyObject *resultobj = 0;
41769 wxMenu *arg1 = (wxMenu *) 0 ;
41770 int arg2 ;
41771 wxString *arg3 = 0 ;
41772 wxString const &arg4_defvalue = wxPyEmptyString ;
41773 wxString *arg4 = (wxString *) &arg4_defvalue ;
41774 wxMenuItem *result = 0 ;
41775 void *argp1 = 0 ;
41776 int res1 = 0 ;
41777 int val2 ;
41778 int ecode2 = 0 ;
41779 bool temp3 = false ;
41780 bool temp4 = false ;
41781 PyObject * obj0 = 0 ;
41782 PyObject * obj1 = 0 ;
41783 PyObject * obj2 = 0 ;
41784 PyObject * obj3 = 0 ;
41785 char * kwnames[] = {
41786 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
41787 };
41788
41789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41791 if (!SWIG_IsOK(res1)) {
41792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41793 }
41794 arg1 = reinterpret_cast< wxMenu * >(argp1);
41795 ecode2 = SWIG_AsVal_int(obj1, &val2);
41796 if (!SWIG_IsOK(ecode2)) {
41797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
41798 }
41799 arg2 = static_cast< int >(val2);
41800 {
41801 arg3 = wxString_in_helper(obj2);
41802 if (arg3 == NULL) SWIG_fail;
41803 temp3 = true;
41804 }
41805 if (obj3) {
41806 {
41807 arg4 = wxString_in_helper(obj3);
41808 if (arg4 == NULL) SWIG_fail;
41809 temp4 = true;
41810 }
41811 }
41812 {
41813 PyThreadState* __tstate = wxPyBeginAllowThreads();
41814 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
41815 wxPyEndAllowThreads(__tstate);
41816 if (PyErr_Occurred()) SWIG_fail;
41817 }
41818 {
41819 resultobj = wxPyMake_wxObject(result, (bool)0);
41820 }
41821 {
41822 if (temp3)
41823 delete arg3;
41824 }
41825 {
41826 if (temp4)
41827 delete arg4;
41828 }
41829 return resultobj;
41830 fail:
41831 {
41832 if (temp3)
41833 delete arg3;
41834 }
41835 {
41836 if (temp4)
41837 delete arg4;
41838 }
41839 return NULL;
41840 }
41841
41842
41843 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41844 PyObject *resultobj = 0;
41845 wxMenu *arg1 = (wxMenu *) 0 ;
41846 int arg2 ;
41847 wxString *arg3 = 0 ;
41848 wxString const &arg4_defvalue = wxPyEmptyString ;
41849 wxString *arg4 = (wxString *) &arg4_defvalue ;
41850 wxMenuItem *result = 0 ;
41851 void *argp1 = 0 ;
41852 int res1 = 0 ;
41853 int val2 ;
41854 int ecode2 = 0 ;
41855 bool temp3 = false ;
41856 bool temp4 = false ;
41857 PyObject * obj0 = 0 ;
41858 PyObject * obj1 = 0 ;
41859 PyObject * obj2 = 0 ;
41860 PyObject * obj3 = 0 ;
41861 char * kwnames[] = {
41862 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
41863 };
41864
41865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41867 if (!SWIG_IsOK(res1)) {
41868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41869 }
41870 arg1 = reinterpret_cast< wxMenu * >(argp1);
41871 ecode2 = SWIG_AsVal_int(obj1, &val2);
41872 if (!SWIG_IsOK(ecode2)) {
41873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
41874 }
41875 arg2 = static_cast< int >(val2);
41876 {
41877 arg3 = wxString_in_helper(obj2);
41878 if (arg3 == NULL) SWIG_fail;
41879 temp3 = true;
41880 }
41881 if (obj3) {
41882 {
41883 arg4 = wxString_in_helper(obj3);
41884 if (arg4 == NULL) SWIG_fail;
41885 temp4 = true;
41886 }
41887 }
41888 {
41889 PyThreadState* __tstate = wxPyBeginAllowThreads();
41890 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
41891 wxPyEndAllowThreads(__tstate);
41892 if (PyErr_Occurred()) SWIG_fail;
41893 }
41894 {
41895 resultobj = wxPyMake_wxObject(result, (bool)0);
41896 }
41897 {
41898 if (temp3)
41899 delete arg3;
41900 }
41901 {
41902 if (temp4)
41903 delete arg4;
41904 }
41905 return resultobj;
41906 fail:
41907 {
41908 if (temp3)
41909 delete arg3;
41910 }
41911 {
41912 if (temp4)
41913 delete arg4;
41914 }
41915 return NULL;
41916 }
41917
41918
41919 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41920 PyObject *resultobj = 0;
41921 wxMenu *arg1 = (wxMenu *) 0 ;
41922 int arg2 ;
41923 wxString *arg3 = 0 ;
41924 wxMenu *arg4 = (wxMenu *) 0 ;
41925 wxString const &arg5_defvalue = wxPyEmptyString ;
41926 wxString *arg5 = (wxString *) &arg5_defvalue ;
41927 wxMenuItem *result = 0 ;
41928 void *argp1 = 0 ;
41929 int res1 = 0 ;
41930 int val2 ;
41931 int ecode2 = 0 ;
41932 bool temp3 = false ;
41933 void *argp4 = 0 ;
41934 int res4 = 0 ;
41935 bool temp5 = false ;
41936 PyObject * obj0 = 0 ;
41937 PyObject * obj1 = 0 ;
41938 PyObject * obj2 = 0 ;
41939 PyObject * obj3 = 0 ;
41940 PyObject * obj4 = 0 ;
41941 char * kwnames[] = {
41942 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
41943 };
41944
41945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
41946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41947 if (!SWIG_IsOK(res1)) {
41948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
41949 }
41950 arg1 = reinterpret_cast< wxMenu * >(argp1);
41951 ecode2 = SWIG_AsVal_int(obj1, &val2);
41952 if (!SWIG_IsOK(ecode2)) {
41953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
41954 }
41955 arg2 = static_cast< int >(val2);
41956 {
41957 arg3 = wxString_in_helper(obj2);
41958 if (arg3 == NULL) SWIG_fail;
41959 temp3 = true;
41960 }
41961 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
41962 if (!SWIG_IsOK(res4)) {
41963 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
41964 }
41965 arg4 = reinterpret_cast< wxMenu * >(argp4);
41966 if (obj4) {
41967 {
41968 arg5 = wxString_in_helper(obj4);
41969 if (arg5 == NULL) SWIG_fail;
41970 temp5 = true;
41971 }
41972 }
41973 {
41974 PyThreadState* __tstate = wxPyBeginAllowThreads();
41975 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
41976 wxPyEndAllowThreads(__tstate);
41977 if (PyErr_Occurred()) SWIG_fail;
41978 }
41979 {
41980 resultobj = wxPyMake_wxObject(result, (bool)0);
41981 }
41982 {
41983 if (temp3)
41984 delete arg3;
41985 }
41986 {
41987 if (temp5)
41988 delete arg5;
41989 }
41990 return resultobj;
41991 fail:
41992 {
41993 if (temp3)
41994 delete arg3;
41995 }
41996 {
41997 if (temp5)
41998 delete arg5;
41999 }
42000 return NULL;
42001 }
42002
42003
42004 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42005 PyObject *resultobj = 0;
42006 wxMenu *arg1 = (wxMenu *) 0 ;
42007 wxMenu *arg2 = (wxMenu *) 0 ;
42008 wxString *arg3 = 0 ;
42009 wxString const &arg4_defvalue = wxPyEmptyString ;
42010 wxString *arg4 = (wxString *) &arg4_defvalue ;
42011 wxMenuItem *result = 0 ;
42012 void *argp1 = 0 ;
42013 int res1 = 0 ;
42014 void *argp2 = 0 ;
42015 int res2 = 0 ;
42016 bool temp3 = false ;
42017 bool temp4 = false ;
42018 PyObject * obj0 = 0 ;
42019 PyObject * obj1 = 0 ;
42020 PyObject * obj2 = 0 ;
42021 PyObject * obj3 = 0 ;
42022 char * kwnames[] = {
42023 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
42024 };
42025
42026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42028 if (!SWIG_IsOK(res1)) {
42029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42030 }
42031 arg1 = reinterpret_cast< wxMenu * >(argp1);
42032 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42033 if (!SWIG_IsOK(res2)) {
42034 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42035 }
42036 arg2 = reinterpret_cast< wxMenu * >(argp2);
42037 {
42038 arg3 = wxString_in_helper(obj2);
42039 if (arg3 == NULL) SWIG_fail;
42040 temp3 = true;
42041 }
42042 if (obj3) {
42043 {
42044 arg4 = wxString_in_helper(obj3);
42045 if (arg4 == NULL) SWIG_fail;
42046 temp4 = true;
42047 }
42048 }
42049 {
42050 PyThreadState* __tstate = wxPyBeginAllowThreads();
42051 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42052 wxPyEndAllowThreads(__tstate);
42053 if (PyErr_Occurred()) SWIG_fail;
42054 }
42055 {
42056 resultobj = wxPyMake_wxObject(result, (bool)0);
42057 }
42058 {
42059 if (temp3)
42060 delete arg3;
42061 }
42062 {
42063 if (temp4)
42064 delete arg4;
42065 }
42066 return resultobj;
42067 fail:
42068 {
42069 if (temp3)
42070 delete arg3;
42071 }
42072 {
42073 if (temp4)
42074 delete arg4;
42075 }
42076 return NULL;
42077 }
42078
42079
42080 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42081 PyObject *resultobj = 0;
42082 wxMenu *arg1 = (wxMenu *) 0 ;
42083 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42084 wxMenuItem *result = 0 ;
42085 void *argp1 = 0 ;
42086 int res1 = 0 ;
42087 int res2 = 0 ;
42088 PyObject * obj0 = 0 ;
42089 PyObject * obj1 = 0 ;
42090 char * kwnames[] = {
42091 (char *) "self",(char *) "item", NULL
42092 };
42093
42094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
42095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42096 if (!SWIG_IsOK(res1)) {
42097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42098 }
42099 arg1 = reinterpret_cast< wxMenu * >(argp1);
42100 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42101 if (!SWIG_IsOK(res2)) {
42102 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42103 }
42104 {
42105 PyThreadState* __tstate = wxPyBeginAllowThreads();
42106 result = (wxMenuItem *)(arg1)->Append(arg2);
42107 wxPyEndAllowThreads(__tstate);
42108 if (PyErr_Occurred()) SWIG_fail;
42109 }
42110 {
42111 resultobj = wxPyMake_wxObject(result, (bool)0);
42112 }
42113 return resultobj;
42114 fail:
42115 return NULL;
42116 }
42117
42118
42119 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42120 PyObject *resultobj = 0;
42121 wxMenu *arg1 = (wxMenu *) 0 ;
42122 size_t arg2 ;
42123 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
42124 wxMenuItem *result = 0 ;
42125 void *argp1 = 0 ;
42126 int res1 = 0 ;
42127 size_t val2 ;
42128 int ecode2 = 0 ;
42129 int res3 = 0 ;
42130 PyObject * obj0 = 0 ;
42131 PyObject * obj1 = 0 ;
42132 PyObject * obj2 = 0 ;
42133 char * kwnames[] = {
42134 (char *) "self",(char *) "pos",(char *) "item", NULL
42135 };
42136
42137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42139 if (!SWIG_IsOK(res1)) {
42140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42141 }
42142 arg1 = reinterpret_cast< wxMenu * >(argp1);
42143 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42144 if (!SWIG_IsOK(ecode2)) {
42145 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
42146 }
42147 arg2 = static_cast< size_t >(val2);
42148 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42149 if (!SWIG_IsOK(res3)) {
42150 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
42151 }
42152 {
42153 PyThreadState* __tstate = wxPyBeginAllowThreads();
42154 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
42155 wxPyEndAllowThreads(__tstate);
42156 if (PyErr_Occurred()) SWIG_fail;
42157 }
42158 {
42159 resultobj = wxPyMake_wxObject(result, (bool)0);
42160 }
42161 return resultobj;
42162 fail:
42163 return NULL;
42164 }
42165
42166
42167 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42168 PyObject *resultobj = 0;
42169 wxMenu *arg1 = (wxMenu *) 0 ;
42170 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42171 wxMenuItem *result = 0 ;
42172 void *argp1 = 0 ;
42173 int res1 = 0 ;
42174 int res2 = 0 ;
42175 PyObject * obj0 = 0 ;
42176 PyObject * obj1 = 0 ;
42177 char * kwnames[] = {
42178 (char *) "self",(char *) "item", NULL
42179 };
42180
42181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
42182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42183 if (!SWIG_IsOK(res1)) {
42184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42185 }
42186 arg1 = reinterpret_cast< wxMenu * >(argp1);
42187 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42188 if (!SWIG_IsOK(res2)) {
42189 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42190 }
42191 {
42192 PyThreadState* __tstate = wxPyBeginAllowThreads();
42193 result = (wxMenuItem *)(arg1)->Prepend(arg2);
42194 wxPyEndAllowThreads(__tstate);
42195 if (PyErr_Occurred()) SWIG_fail;
42196 }
42197 {
42198 resultobj = wxPyMake_wxObject(result, (bool)0);
42199 }
42200 return resultobj;
42201 fail:
42202 return NULL;
42203 }
42204
42205
42206 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42207 PyObject *resultobj = 0;
42208 wxMenu *arg1 = (wxMenu *) 0 ;
42209 void *argp1 = 0 ;
42210 int res1 = 0 ;
42211 PyObject *swig_obj[1] ;
42212
42213 if (!args) SWIG_fail;
42214 swig_obj[0] = args;
42215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42216 if (!SWIG_IsOK(res1)) {
42217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
42218 }
42219 arg1 = reinterpret_cast< wxMenu * >(argp1);
42220 {
42221 PyThreadState* __tstate = wxPyBeginAllowThreads();
42222 (arg1)->Break();
42223 wxPyEndAllowThreads(__tstate);
42224 if (PyErr_Occurred()) SWIG_fail;
42225 }
42226 resultobj = SWIG_Py_Void();
42227 return resultobj;
42228 fail:
42229 return NULL;
42230 }
42231
42232
42233 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42234 PyObject *resultobj = 0;
42235 wxMenu *arg1 = (wxMenu *) 0 ;
42236 size_t arg2 ;
42237 int arg3 ;
42238 wxString const &arg4_defvalue = wxPyEmptyString ;
42239 wxString *arg4 = (wxString *) &arg4_defvalue ;
42240 wxString const &arg5_defvalue = wxPyEmptyString ;
42241 wxString *arg5 = (wxString *) &arg5_defvalue ;
42242 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
42243 wxMenuItem *result = 0 ;
42244 void *argp1 = 0 ;
42245 int res1 = 0 ;
42246 size_t val2 ;
42247 int ecode2 = 0 ;
42248 int val3 ;
42249 int ecode3 = 0 ;
42250 bool temp4 = false ;
42251 bool temp5 = false ;
42252 int val6 ;
42253 int ecode6 = 0 ;
42254 PyObject * obj0 = 0 ;
42255 PyObject * obj1 = 0 ;
42256 PyObject * obj2 = 0 ;
42257 PyObject * obj3 = 0 ;
42258 PyObject * obj4 = 0 ;
42259 PyObject * obj5 = 0 ;
42260 char * kwnames[] = {
42261 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42262 };
42263
42264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42266 if (!SWIG_IsOK(res1)) {
42267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
42268 }
42269 arg1 = reinterpret_cast< wxMenu * >(argp1);
42270 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42271 if (!SWIG_IsOK(ecode2)) {
42272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
42273 }
42274 arg2 = static_cast< size_t >(val2);
42275 ecode3 = SWIG_AsVal_int(obj2, &val3);
42276 if (!SWIG_IsOK(ecode3)) {
42277 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
42278 }
42279 arg3 = static_cast< int >(val3);
42280 if (obj3) {
42281 {
42282 arg4 = wxString_in_helper(obj3);
42283 if (arg4 == NULL) SWIG_fail;
42284 temp4 = true;
42285 }
42286 }
42287 if (obj4) {
42288 {
42289 arg5 = wxString_in_helper(obj4);
42290 if (arg5 == NULL) SWIG_fail;
42291 temp5 = true;
42292 }
42293 }
42294 if (obj5) {
42295 ecode6 = SWIG_AsVal_int(obj5, &val6);
42296 if (!SWIG_IsOK(ecode6)) {
42297 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
42298 }
42299 arg6 = static_cast< wxItemKind >(val6);
42300 }
42301 {
42302 PyThreadState* __tstate = wxPyBeginAllowThreads();
42303 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
42304 wxPyEndAllowThreads(__tstate);
42305 if (PyErr_Occurred()) SWIG_fail;
42306 }
42307 {
42308 resultobj = wxPyMake_wxObject(result, (bool)0);
42309 }
42310 {
42311 if (temp4)
42312 delete arg4;
42313 }
42314 {
42315 if (temp5)
42316 delete arg5;
42317 }
42318 return resultobj;
42319 fail:
42320 {
42321 if (temp4)
42322 delete arg4;
42323 }
42324 {
42325 if (temp5)
42326 delete arg5;
42327 }
42328 return NULL;
42329 }
42330
42331
42332 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42333 PyObject *resultobj = 0;
42334 wxMenu *arg1 = (wxMenu *) 0 ;
42335 size_t arg2 ;
42336 wxMenuItem *result = 0 ;
42337 void *argp1 = 0 ;
42338 int res1 = 0 ;
42339 size_t val2 ;
42340 int ecode2 = 0 ;
42341 PyObject * obj0 = 0 ;
42342 PyObject * obj1 = 0 ;
42343 char * kwnames[] = {
42344 (char *) "self",(char *) "pos", NULL
42345 };
42346
42347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
42348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42349 if (!SWIG_IsOK(res1)) {
42350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42351 }
42352 arg1 = reinterpret_cast< wxMenu * >(argp1);
42353 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42354 if (!SWIG_IsOK(ecode2)) {
42355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
42356 }
42357 arg2 = static_cast< size_t >(val2);
42358 {
42359 PyThreadState* __tstate = wxPyBeginAllowThreads();
42360 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
42361 wxPyEndAllowThreads(__tstate);
42362 if (PyErr_Occurred()) SWIG_fail;
42363 }
42364 {
42365 resultobj = wxPyMake_wxObject(result, (bool)0);
42366 }
42367 return resultobj;
42368 fail:
42369 return NULL;
42370 }
42371
42372
42373 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42374 PyObject *resultobj = 0;
42375 wxMenu *arg1 = (wxMenu *) 0 ;
42376 size_t arg2 ;
42377 int arg3 ;
42378 wxString *arg4 = 0 ;
42379 wxString const &arg5_defvalue = wxPyEmptyString ;
42380 wxString *arg5 = (wxString *) &arg5_defvalue ;
42381 wxMenuItem *result = 0 ;
42382 void *argp1 = 0 ;
42383 int res1 = 0 ;
42384 size_t val2 ;
42385 int ecode2 = 0 ;
42386 int val3 ;
42387 int ecode3 = 0 ;
42388 bool temp4 = false ;
42389 bool temp5 = false ;
42390 PyObject * obj0 = 0 ;
42391 PyObject * obj1 = 0 ;
42392 PyObject * obj2 = 0 ;
42393 PyObject * obj3 = 0 ;
42394 PyObject * obj4 = 0 ;
42395 char * kwnames[] = {
42396 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42397 };
42398
42399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42401 if (!SWIG_IsOK(res1)) {
42402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42403 }
42404 arg1 = reinterpret_cast< wxMenu * >(argp1);
42405 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42406 if (!SWIG_IsOK(ecode2)) {
42407 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
42408 }
42409 arg2 = static_cast< size_t >(val2);
42410 ecode3 = SWIG_AsVal_int(obj2, &val3);
42411 if (!SWIG_IsOK(ecode3)) {
42412 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
42413 }
42414 arg3 = static_cast< int >(val3);
42415 {
42416 arg4 = wxString_in_helper(obj3);
42417 if (arg4 == NULL) SWIG_fail;
42418 temp4 = true;
42419 }
42420 if (obj4) {
42421 {
42422 arg5 = wxString_in_helper(obj4);
42423 if (arg5 == NULL) SWIG_fail;
42424 temp5 = true;
42425 }
42426 }
42427 {
42428 PyThreadState* __tstate = wxPyBeginAllowThreads();
42429 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42430 wxPyEndAllowThreads(__tstate);
42431 if (PyErr_Occurred()) SWIG_fail;
42432 }
42433 {
42434 resultobj = wxPyMake_wxObject(result, (bool)0);
42435 }
42436 {
42437 if (temp4)
42438 delete arg4;
42439 }
42440 {
42441 if (temp5)
42442 delete arg5;
42443 }
42444 return resultobj;
42445 fail:
42446 {
42447 if (temp4)
42448 delete arg4;
42449 }
42450 {
42451 if (temp5)
42452 delete arg5;
42453 }
42454 return NULL;
42455 }
42456
42457
42458 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42459 PyObject *resultobj = 0;
42460 wxMenu *arg1 = (wxMenu *) 0 ;
42461 size_t arg2 ;
42462 int arg3 ;
42463 wxString *arg4 = 0 ;
42464 wxString const &arg5_defvalue = wxPyEmptyString ;
42465 wxString *arg5 = (wxString *) &arg5_defvalue ;
42466 wxMenuItem *result = 0 ;
42467 void *argp1 = 0 ;
42468 int res1 = 0 ;
42469 size_t val2 ;
42470 int ecode2 = 0 ;
42471 int val3 ;
42472 int ecode3 = 0 ;
42473 bool temp4 = false ;
42474 bool temp5 = false ;
42475 PyObject * obj0 = 0 ;
42476 PyObject * obj1 = 0 ;
42477 PyObject * obj2 = 0 ;
42478 PyObject * obj3 = 0 ;
42479 PyObject * obj4 = 0 ;
42480 char * kwnames[] = {
42481 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42482 };
42483
42484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42486 if (!SWIG_IsOK(res1)) {
42487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42488 }
42489 arg1 = reinterpret_cast< wxMenu * >(argp1);
42490 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42491 if (!SWIG_IsOK(ecode2)) {
42492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
42493 }
42494 arg2 = static_cast< size_t >(val2);
42495 ecode3 = SWIG_AsVal_int(obj2, &val3);
42496 if (!SWIG_IsOK(ecode3)) {
42497 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
42498 }
42499 arg3 = static_cast< int >(val3);
42500 {
42501 arg4 = wxString_in_helper(obj3);
42502 if (arg4 == NULL) SWIG_fail;
42503 temp4 = true;
42504 }
42505 if (obj4) {
42506 {
42507 arg5 = wxString_in_helper(obj4);
42508 if (arg5 == NULL) SWIG_fail;
42509 temp5 = true;
42510 }
42511 }
42512 {
42513 PyThreadState* __tstate = wxPyBeginAllowThreads();
42514 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42515 wxPyEndAllowThreads(__tstate);
42516 if (PyErr_Occurred()) SWIG_fail;
42517 }
42518 {
42519 resultobj = wxPyMake_wxObject(result, (bool)0);
42520 }
42521 {
42522 if (temp4)
42523 delete arg4;
42524 }
42525 {
42526 if (temp5)
42527 delete arg5;
42528 }
42529 return resultobj;
42530 fail:
42531 {
42532 if (temp4)
42533 delete arg4;
42534 }
42535 {
42536 if (temp5)
42537 delete arg5;
42538 }
42539 return NULL;
42540 }
42541
42542
42543 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42544 PyObject *resultobj = 0;
42545 wxMenu *arg1 = (wxMenu *) 0 ;
42546 size_t arg2 ;
42547 int arg3 ;
42548 wxString *arg4 = 0 ;
42549 wxMenu *arg5 = (wxMenu *) 0 ;
42550 wxString const &arg6_defvalue = wxPyEmptyString ;
42551 wxString *arg6 = (wxString *) &arg6_defvalue ;
42552 wxMenuItem *result = 0 ;
42553 void *argp1 = 0 ;
42554 int res1 = 0 ;
42555 size_t val2 ;
42556 int ecode2 = 0 ;
42557 int val3 ;
42558 int ecode3 = 0 ;
42559 bool temp4 = false ;
42560 void *argp5 = 0 ;
42561 int res5 = 0 ;
42562 bool temp6 = false ;
42563 PyObject * obj0 = 0 ;
42564 PyObject * obj1 = 0 ;
42565 PyObject * obj2 = 0 ;
42566 PyObject * obj3 = 0 ;
42567 PyObject * obj4 = 0 ;
42568 PyObject * obj5 = 0 ;
42569 char * kwnames[] = {
42570 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42571 };
42572
42573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42575 if (!SWIG_IsOK(res1)) {
42576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42577 }
42578 arg1 = reinterpret_cast< wxMenu * >(argp1);
42579 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42580 if (!SWIG_IsOK(ecode2)) {
42581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
42582 }
42583 arg2 = static_cast< size_t >(val2);
42584 ecode3 = SWIG_AsVal_int(obj2, &val3);
42585 if (!SWIG_IsOK(ecode3)) {
42586 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
42587 }
42588 arg3 = static_cast< int >(val3);
42589 {
42590 arg4 = wxString_in_helper(obj3);
42591 if (arg4 == NULL) SWIG_fail;
42592 temp4 = true;
42593 }
42594 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
42595 if (!SWIG_IsOK(res5)) {
42596 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
42597 }
42598 arg5 = reinterpret_cast< wxMenu * >(argp5);
42599 if (obj5) {
42600 {
42601 arg6 = wxString_in_helper(obj5);
42602 if (arg6 == NULL) SWIG_fail;
42603 temp6 = true;
42604 }
42605 }
42606 {
42607 PyThreadState* __tstate = wxPyBeginAllowThreads();
42608 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
42609 wxPyEndAllowThreads(__tstate);
42610 if (PyErr_Occurred()) SWIG_fail;
42611 }
42612 {
42613 resultobj = wxPyMake_wxObject(result, (bool)0);
42614 }
42615 {
42616 if (temp4)
42617 delete arg4;
42618 }
42619 {
42620 if (temp6)
42621 delete arg6;
42622 }
42623 return resultobj;
42624 fail:
42625 {
42626 if (temp4)
42627 delete arg4;
42628 }
42629 {
42630 if (temp6)
42631 delete arg6;
42632 }
42633 return NULL;
42634 }
42635
42636
42637 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42638 PyObject *resultobj = 0;
42639 wxMenu *arg1 = (wxMenu *) 0 ;
42640 int arg2 ;
42641 wxString const &arg3_defvalue = wxPyEmptyString ;
42642 wxString *arg3 = (wxString *) &arg3_defvalue ;
42643 wxString const &arg4_defvalue = wxPyEmptyString ;
42644 wxString *arg4 = (wxString *) &arg4_defvalue ;
42645 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42646 wxMenuItem *result = 0 ;
42647 void *argp1 = 0 ;
42648 int res1 = 0 ;
42649 int val2 ;
42650 int ecode2 = 0 ;
42651 bool temp3 = false ;
42652 bool temp4 = false ;
42653 int val5 ;
42654 int ecode5 = 0 ;
42655 PyObject * obj0 = 0 ;
42656 PyObject * obj1 = 0 ;
42657 PyObject * obj2 = 0 ;
42658 PyObject * obj3 = 0 ;
42659 PyObject * obj4 = 0 ;
42660 char * kwnames[] = {
42661 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42662 };
42663
42664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42666 if (!SWIG_IsOK(res1)) {
42667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
42668 }
42669 arg1 = reinterpret_cast< wxMenu * >(argp1);
42670 ecode2 = SWIG_AsVal_int(obj1, &val2);
42671 if (!SWIG_IsOK(ecode2)) {
42672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
42673 }
42674 arg2 = static_cast< int >(val2);
42675 if (obj2) {
42676 {
42677 arg3 = wxString_in_helper(obj2);
42678 if (arg3 == NULL) SWIG_fail;
42679 temp3 = true;
42680 }
42681 }
42682 if (obj3) {
42683 {
42684 arg4 = wxString_in_helper(obj3);
42685 if (arg4 == NULL) SWIG_fail;
42686 temp4 = true;
42687 }
42688 }
42689 if (obj4) {
42690 ecode5 = SWIG_AsVal_int(obj4, &val5);
42691 if (!SWIG_IsOK(ecode5)) {
42692 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
42693 }
42694 arg5 = static_cast< wxItemKind >(val5);
42695 }
42696 {
42697 PyThreadState* __tstate = wxPyBeginAllowThreads();
42698 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
42699 wxPyEndAllowThreads(__tstate);
42700 if (PyErr_Occurred()) SWIG_fail;
42701 }
42702 {
42703 resultobj = wxPyMake_wxObject(result, (bool)0);
42704 }
42705 {
42706 if (temp3)
42707 delete arg3;
42708 }
42709 {
42710 if (temp4)
42711 delete arg4;
42712 }
42713 return resultobj;
42714 fail:
42715 {
42716 if (temp3)
42717 delete arg3;
42718 }
42719 {
42720 if (temp4)
42721 delete arg4;
42722 }
42723 return NULL;
42724 }
42725
42726
42727 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42728 PyObject *resultobj = 0;
42729 wxMenu *arg1 = (wxMenu *) 0 ;
42730 wxMenuItem *result = 0 ;
42731 void *argp1 = 0 ;
42732 int res1 = 0 ;
42733 PyObject *swig_obj[1] ;
42734
42735 if (!args) SWIG_fail;
42736 swig_obj[0] = args;
42737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42738 if (!SWIG_IsOK(res1)) {
42739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42740 }
42741 arg1 = reinterpret_cast< wxMenu * >(argp1);
42742 {
42743 PyThreadState* __tstate = wxPyBeginAllowThreads();
42744 result = (wxMenuItem *)(arg1)->PrependSeparator();
42745 wxPyEndAllowThreads(__tstate);
42746 if (PyErr_Occurred()) SWIG_fail;
42747 }
42748 {
42749 resultobj = wxPyMake_wxObject(result, (bool)0);
42750 }
42751 return resultobj;
42752 fail:
42753 return NULL;
42754 }
42755
42756
42757 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42758 PyObject *resultobj = 0;
42759 wxMenu *arg1 = (wxMenu *) 0 ;
42760 int arg2 ;
42761 wxString *arg3 = 0 ;
42762 wxString const &arg4_defvalue = wxPyEmptyString ;
42763 wxString *arg4 = (wxString *) &arg4_defvalue ;
42764 wxMenuItem *result = 0 ;
42765 void *argp1 = 0 ;
42766 int res1 = 0 ;
42767 int val2 ;
42768 int ecode2 = 0 ;
42769 bool temp3 = false ;
42770 bool temp4 = false ;
42771 PyObject * obj0 = 0 ;
42772 PyObject * obj1 = 0 ;
42773 PyObject * obj2 = 0 ;
42774 PyObject * obj3 = 0 ;
42775 char * kwnames[] = {
42776 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42777 };
42778
42779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42781 if (!SWIG_IsOK(res1)) {
42782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42783 }
42784 arg1 = reinterpret_cast< wxMenu * >(argp1);
42785 ecode2 = SWIG_AsVal_int(obj1, &val2);
42786 if (!SWIG_IsOK(ecode2)) {
42787 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
42788 }
42789 arg2 = static_cast< int >(val2);
42790 {
42791 arg3 = wxString_in_helper(obj2);
42792 if (arg3 == NULL) SWIG_fail;
42793 temp3 = true;
42794 }
42795 if (obj3) {
42796 {
42797 arg4 = wxString_in_helper(obj3);
42798 if (arg4 == NULL) SWIG_fail;
42799 temp4 = true;
42800 }
42801 }
42802 {
42803 PyThreadState* __tstate = wxPyBeginAllowThreads();
42804 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42805 wxPyEndAllowThreads(__tstate);
42806 if (PyErr_Occurred()) SWIG_fail;
42807 }
42808 {
42809 resultobj = wxPyMake_wxObject(result, (bool)0);
42810 }
42811 {
42812 if (temp3)
42813 delete arg3;
42814 }
42815 {
42816 if (temp4)
42817 delete arg4;
42818 }
42819 return resultobj;
42820 fail:
42821 {
42822 if (temp3)
42823 delete arg3;
42824 }
42825 {
42826 if (temp4)
42827 delete arg4;
42828 }
42829 return NULL;
42830 }
42831
42832
42833 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42834 PyObject *resultobj = 0;
42835 wxMenu *arg1 = (wxMenu *) 0 ;
42836 int arg2 ;
42837 wxString *arg3 = 0 ;
42838 wxString const &arg4_defvalue = wxPyEmptyString ;
42839 wxString *arg4 = (wxString *) &arg4_defvalue ;
42840 wxMenuItem *result = 0 ;
42841 void *argp1 = 0 ;
42842 int res1 = 0 ;
42843 int val2 ;
42844 int ecode2 = 0 ;
42845 bool temp3 = false ;
42846 bool temp4 = false ;
42847 PyObject * obj0 = 0 ;
42848 PyObject * obj1 = 0 ;
42849 PyObject * obj2 = 0 ;
42850 PyObject * obj3 = 0 ;
42851 char * kwnames[] = {
42852 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42853 };
42854
42855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42857 if (!SWIG_IsOK(res1)) {
42858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42859 }
42860 arg1 = reinterpret_cast< wxMenu * >(argp1);
42861 ecode2 = SWIG_AsVal_int(obj1, &val2);
42862 if (!SWIG_IsOK(ecode2)) {
42863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
42864 }
42865 arg2 = static_cast< int >(val2);
42866 {
42867 arg3 = wxString_in_helper(obj2);
42868 if (arg3 == NULL) SWIG_fail;
42869 temp3 = true;
42870 }
42871 if (obj3) {
42872 {
42873 arg4 = wxString_in_helper(obj3);
42874 if (arg4 == NULL) SWIG_fail;
42875 temp4 = true;
42876 }
42877 }
42878 {
42879 PyThreadState* __tstate = wxPyBeginAllowThreads();
42880 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42881 wxPyEndAllowThreads(__tstate);
42882 if (PyErr_Occurred()) SWIG_fail;
42883 }
42884 {
42885 resultobj = wxPyMake_wxObject(result, (bool)0);
42886 }
42887 {
42888 if (temp3)
42889 delete arg3;
42890 }
42891 {
42892 if (temp4)
42893 delete arg4;
42894 }
42895 return resultobj;
42896 fail:
42897 {
42898 if (temp3)
42899 delete arg3;
42900 }
42901 {
42902 if (temp4)
42903 delete arg4;
42904 }
42905 return NULL;
42906 }
42907
42908
42909 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42910 PyObject *resultobj = 0;
42911 wxMenu *arg1 = (wxMenu *) 0 ;
42912 int arg2 ;
42913 wxString *arg3 = 0 ;
42914 wxMenu *arg4 = (wxMenu *) 0 ;
42915 wxString const &arg5_defvalue = wxPyEmptyString ;
42916 wxString *arg5 = (wxString *) &arg5_defvalue ;
42917 wxMenuItem *result = 0 ;
42918 void *argp1 = 0 ;
42919 int res1 = 0 ;
42920 int val2 ;
42921 int ecode2 = 0 ;
42922 bool temp3 = false ;
42923 void *argp4 = 0 ;
42924 int res4 = 0 ;
42925 bool temp5 = false ;
42926 PyObject * obj0 = 0 ;
42927 PyObject * obj1 = 0 ;
42928 PyObject * obj2 = 0 ;
42929 PyObject * obj3 = 0 ;
42930 PyObject * obj4 = 0 ;
42931 char * kwnames[] = {
42932 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42933 };
42934
42935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42937 if (!SWIG_IsOK(res1)) {
42938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42939 }
42940 arg1 = reinterpret_cast< wxMenu * >(argp1);
42941 ecode2 = SWIG_AsVal_int(obj1, &val2);
42942 if (!SWIG_IsOK(ecode2)) {
42943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
42944 }
42945 arg2 = static_cast< int >(val2);
42946 {
42947 arg3 = wxString_in_helper(obj2);
42948 if (arg3 == NULL) SWIG_fail;
42949 temp3 = true;
42950 }
42951 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
42952 if (!SWIG_IsOK(res4)) {
42953 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
42954 }
42955 arg4 = reinterpret_cast< wxMenu * >(argp4);
42956 if (obj4) {
42957 {
42958 arg5 = wxString_in_helper(obj4);
42959 if (arg5 == NULL) SWIG_fail;
42960 temp5 = true;
42961 }
42962 }
42963 {
42964 PyThreadState* __tstate = wxPyBeginAllowThreads();
42965 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
42966 wxPyEndAllowThreads(__tstate);
42967 if (PyErr_Occurred()) SWIG_fail;
42968 }
42969 {
42970 resultobj = wxPyMake_wxObject(result, (bool)0);
42971 }
42972 {
42973 if (temp3)
42974 delete arg3;
42975 }
42976 {
42977 if (temp5)
42978 delete arg5;
42979 }
42980 return resultobj;
42981 fail:
42982 {
42983 if (temp3)
42984 delete arg3;
42985 }
42986 {
42987 if (temp5)
42988 delete arg5;
42989 }
42990 return NULL;
42991 }
42992
42993
42994 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42995 PyObject *resultobj = 0;
42996 wxMenu *arg1 = (wxMenu *) 0 ;
42997 int arg2 ;
42998 wxMenuItem *result = 0 ;
42999 void *argp1 = 0 ;
43000 int res1 = 0 ;
43001 int val2 ;
43002 int ecode2 = 0 ;
43003 PyObject * obj0 = 0 ;
43004 PyObject * obj1 = 0 ;
43005 char * kwnames[] = {
43006 (char *) "self",(char *) "id", NULL
43007 };
43008
43009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
43010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43011 if (!SWIG_IsOK(res1)) {
43012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
43013 }
43014 arg1 = reinterpret_cast< wxMenu * >(argp1);
43015 ecode2 = SWIG_AsVal_int(obj1, &val2);
43016 if (!SWIG_IsOK(ecode2)) {
43017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
43018 }
43019 arg2 = static_cast< int >(val2);
43020 {
43021 PyThreadState* __tstate = wxPyBeginAllowThreads();
43022 result = (wxMenuItem *)(arg1)->Remove(arg2);
43023 wxPyEndAllowThreads(__tstate);
43024 if (PyErr_Occurred()) SWIG_fail;
43025 }
43026 {
43027 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43028 }
43029 return resultobj;
43030 fail:
43031 return NULL;
43032 }
43033
43034
43035 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43036 PyObject *resultobj = 0;
43037 wxMenu *arg1 = (wxMenu *) 0 ;
43038 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43039 wxMenuItem *result = 0 ;
43040 void *argp1 = 0 ;
43041 int res1 = 0 ;
43042 void *argp2 = 0 ;
43043 int res2 = 0 ;
43044 PyObject * obj0 = 0 ;
43045 PyObject * obj1 = 0 ;
43046 char * kwnames[] = {
43047 (char *) "self",(char *) "item", NULL
43048 };
43049
43050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
43051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43052 if (!SWIG_IsOK(res1)) {
43053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43054 }
43055 arg1 = reinterpret_cast< wxMenu * >(argp1);
43056 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43057 if (!SWIG_IsOK(res2)) {
43058 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43059 }
43060 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43061 {
43062 PyThreadState* __tstate = wxPyBeginAllowThreads();
43063 result = (wxMenuItem *)(arg1)->Remove(arg2);
43064 wxPyEndAllowThreads(__tstate);
43065 if (PyErr_Occurred()) SWIG_fail;
43066 }
43067 {
43068 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43069 }
43070 return resultobj;
43071 fail:
43072 return NULL;
43073 }
43074
43075
43076 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43077 PyObject *resultobj = 0;
43078 wxMenu *arg1 = (wxMenu *) 0 ;
43079 int arg2 ;
43080 bool result;
43081 void *argp1 = 0 ;
43082 int res1 = 0 ;
43083 int val2 ;
43084 int ecode2 = 0 ;
43085 PyObject * obj0 = 0 ;
43086 PyObject * obj1 = 0 ;
43087 char * kwnames[] = {
43088 (char *) "self",(char *) "id", NULL
43089 };
43090
43091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
43092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43093 if (!SWIG_IsOK(res1)) {
43094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
43095 }
43096 arg1 = reinterpret_cast< wxMenu * >(argp1);
43097 ecode2 = SWIG_AsVal_int(obj1, &val2);
43098 if (!SWIG_IsOK(ecode2)) {
43099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
43100 }
43101 arg2 = static_cast< int >(val2);
43102 {
43103 PyThreadState* __tstate = wxPyBeginAllowThreads();
43104 result = (bool)(arg1)->Delete(arg2);
43105 wxPyEndAllowThreads(__tstate);
43106 if (PyErr_Occurred()) SWIG_fail;
43107 }
43108 {
43109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43110 }
43111 return resultobj;
43112 fail:
43113 return NULL;
43114 }
43115
43116
43117 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43118 PyObject *resultobj = 0;
43119 wxMenu *arg1 = (wxMenu *) 0 ;
43120 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43121 bool result;
43122 void *argp1 = 0 ;
43123 int res1 = 0 ;
43124 void *argp2 = 0 ;
43125 int res2 = 0 ;
43126 PyObject * obj0 = 0 ;
43127 PyObject * obj1 = 0 ;
43128 char * kwnames[] = {
43129 (char *) "self",(char *) "item", NULL
43130 };
43131
43132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
43133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43134 if (!SWIG_IsOK(res1)) {
43135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43136 }
43137 arg1 = reinterpret_cast< wxMenu * >(argp1);
43138 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43139 if (!SWIG_IsOK(res2)) {
43140 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43141 }
43142 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43143 {
43144 PyThreadState* __tstate = wxPyBeginAllowThreads();
43145 result = (bool)(arg1)->Delete(arg2);
43146 wxPyEndAllowThreads(__tstate);
43147 if (PyErr_Occurred()) SWIG_fail;
43148 }
43149 {
43150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43151 }
43152 return resultobj;
43153 fail:
43154 return NULL;
43155 }
43156
43157
43158 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43159 PyObject *resultobj = 0;
43160 wxMenu *arg1 = (wxMenu *) 0 ;
43161 void *argp1 = 0 ;
43162 int res1 = 0 ;
43163 PyObject *swig_obj[1] ;
43164
43165 if (!args) SWIG_fail;
43166 swig_obj[0] = args;
43167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43168 if (!SWIG_IsOK(res1)) {
43169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
43170 }
43171 arg1 = reinterpret_cast< wxMenu * >(argp1);
43172 {
43173 PyThreadState* __tstate = wxPyBeginAllowThreads();
43174 wxMenu_Destroy(arg1);
43175 wxPyEndAllowThreads(__tstate);
43176 if (PyErr_Occurred()) SWIG_fail;
43177 }
43178 resultobj = SWIG_Py_Void();
43179 return resultobj;
43180 fail:
43181 return NULL;
43182 }
43183
43184
43185 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43186 PyObject *resultobj = 0;
43187 wxMenu *arg1 = (wxMenu *) 0 ;
43188 int arg2 ;
43189 bool result;
43190 void *argp1 = 0 ;
43191 int res1 = 0 ;
43192 int val2 ;
43193 int ecode2 = 0 ;
43194 PyObject * obj0 = 0 ;
43195 PyObject * obj1 = 0 ;
43196 char * kwnames[] = {
43197 (char *) "self",(char *) "id", NULL
43198 };
43199
43200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
43201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43202 if (!SWIG_IsOK(res1)) {
43203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
43204 }
43205 arg1 = reinterpret_cast< wxMenu * >(argp1);
43206 ecode2 = SWIG_AsVal_int(obj1, &val2);
43207 if (!SWIG_IsOK(ecode2)) {
43208 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
43209 }
43210 arg2 = static_cast< int >(val2);
43211 {
43212 PyThreadState* __tstate = wxPyBeginAllowThreads();
43213 result = (bool)(arg1)->Destroy(arg2);
43214 wxPyEndAllowThreads(__tstate);
43215 if (PyErr_Occurred()) SWIG_fail;
43216 }
43217 {
43218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43219 }
43220 return resultobj;
43221 fail:
43222 return NULL;
43223 }
43224
43225
43226 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43227 PyObject *resultobj = 0;
43228 wxMenu *arg1 = (wxMenu *) 0 ;
43229 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43230 bool result;
43231 void *argp1 = 0 ;
43232 int res1 = 0 ;
43233 void *argp2 = 0 ;
43234 int res2 = 0 ;
43235 PyObject * obj0 = 0 ;
43236 PyObject * obj1 = 0 ;
43237 char * kwnames[] = {
43238 (char *) "self",(char *) "item", NULL
43239 };
43240
43241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
43242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43243 if (!SWIG_IsOK(res1)) {
43244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43245 }
43246 arg1 = reinterpret_cast< wxMenu * >(argp1);
43247 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43248 if (!SWIG_IsOK(res2)) {
43249 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43250 }
43251 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43252 {
43253 PyThreadState* __tstate = wxPyBeginAllowThreads();
43254 result = (bool)(arg1)->Destroy(arg2);
43255 wxPyEndAllowThreads(__tstate);
43256 if (PyErr_Occurred()) SWIG_fail;
43257 }
43258 {
43259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43260 }
43261 return resultobj;
43262 fail:
43263 return NULL;
43264 }
43265
43266
43267 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43268 PyObject *resultobj = 0;
43269 wxMenu *arg1 = (wxMenu *) 0 ;
43270 size_t result;
43271 void *argp1 = 0 ;
43272 int res1 = 0 ;
43273 PyObject *swig_obj[1] ;
43274
43275 if (!args) SWIG_fail;
43276 swig_obj[0] = args;
43277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43278 if (!SWIG_IsOK(res1)) {
43279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
43280 }
43281 arg1 = reinterpret_cast< wxMenu * >(argp1);
43282 {
43283 PyThreadState* __tstate = wxPyBeginAllowThreads();
43284 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
43285 wxPyEndAllowThreads(__tstate);
43286 if (PyErr_Occurred()) SWIG_fail;
43287 }
43288 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
43289 return resultobj;
43290 fail:
43291 return NULL;
43292 }
43293
43294
43295 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43296 PyObject *resultobj = 0;
43297 wxMenu *arg1 = (wxMenu *) 0 ;
43298 PyObject *result = 0 ;
43299 void *argp1 = 0 ;
43300 int res1 = 0 ;
43301 PyObject *swig_obj[1] ;
43302
43303 if (!args) SWIG_fail;
43304 swig_obj[0] = args;
43305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43306 if (!SWIG_IsOK(res1)) {
43307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
43308 }
43309 arg1 = reinterpret_cast< wxMenu * >(argp1);
43310 {
43311 PyThreadState* __tstate = wxPyBeginAllowThreads();
43312 result = (PyObject *)wxMenu_GetMenuItems(arg1);
43313 wxPyEndAllowThreads(__tstate);
43314 if (PyErr_Occurred()) SWIG_fail;
43315 }
43316 resultobj = result;
43317 return resultobj;
43318 fail:
43319 return NULL;
43320 }
43321
43322
43323 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43324 PyObject *resultobj = 0;
43325 wxMenu *arg1 = (wxMenu *) 0 ;
43326 wxString *arg2 = 0 ;
43327 int result;
43328 void *argp1 = 0 ;
43329 int res1 = 0 ;
43330 bool temp2 = false ;
43331 PyObject * obj0 = 0 ;
43332 PyObject * obj1 = 0 ;
43333 char * kwnames[] = {
43334 (char *) "self",(char *) "item", NULL
43335 };
43336
43337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
43338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43339 if (!SWIG_IsOK(res1)) {
43340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
43341 }
43342 arg1 = reinterpret_cast< wxMenu * >(argp1);
43343 {
43344 arg2 = wxString_in_helper(obj1);
43345 if (arg2 == NULL) SWIG_fail;
43346 temp2 = true;
43347 }
43348 {
43349 PyThreadState* __tstate = wxPyBeginAllowThreads();
43350 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
43351 wxPyEndAllowThreads(__tstate);
43352 if (PyErr_Occurred()) SWIG_fail;
43353 }
43354 resultobj = SWIG_From_int(static_cast< int >(result));
43355 {
43356 if (temp2)
43357 delete arg2;
43358 }
43359 return resultobj;
43360 fail:
43361 {
43362 if (temp2)
43363 delete arg2;
43364 }
43365 return NULL;
43366 }
43367
43368
43369 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43370 PyObject *resultobj = 0;
43371 wxMenu *arg1 = (wxMenu *) 0 ;
43372 int arg2 ;
43373 wxMenuItem *result = 0 ;
43374 void *argp1 = 0 ;
43375 int res1 = 0 ;
43376 int val2 ;
43377 int ecode2 = 0 ;
43378 PyObject * obj0 = 0 ;
43379 PyObject * obj1 = 0 ;
43380 char * kwnames[] = {
43381 (char *) "self",(char *) "id", NULL
43382 };
43383
43384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
43385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43386 if (!SWIG_IsOK(res1)) {
43387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
43388 }
43389 arg1 = reinterpret_cast< wxMenu * >(argp1);
43390 ecode2 = SWIG_AsVal_int(obj1, &val2);
43391 if (!SWIG_IsOK(ecode2)) {
43392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
43393 }
43394 arg2 = static_cast< int >(val2);
43395 {
43396 PyThreadState* __tstate = wxPyBeginAllowThreads();
43397 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
43398 wxPyEndAllowThreads(__tstate);
43399 if (PyErr_Occurred()) SWIG_fail;
43400 }
43401 {
43402 resultobj = wxPyMake_wxObject(result, (bool)0);
43403 }
43404 return resultobj;
43405 fail:
43406 return NULL;
43407 }
43408
43409
43410 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43411 PyObject *resultobj = 0;
43412 wxMenu *arg1 = (wxMenu *) 0 ;
43413 size_t arg2 ;
43414 wxMenuItem *result = 0 ;
43415 void *argp1 = 0 ;
43416 int res1 = 0 ;
43417 size_t val2 ;
43418 int ecode2 = 0 ;
43419 PyObject * obj0 = 0 ;
43420 PyObject * obj1 = 0 ;
43421 char * kwnames[] = {
43422 (char *) "self",(char *) "position", NULL
43423 };
43424
43425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
43426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43427 if (!SWIG_IsOK(res1)) {
43428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
43429 }
43430 arg1 = reinterpret_cast< wxMenu * >(argp1);
43431 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43432 if (!SWIG_IsOK(ecode2)) {
43433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
43434 }
43435 arg2 = static_cast< size_t >(val2);
43436 {
43437 PyThreadState* __tstate = wxPyBeginAllowThreads();
43438 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
43439 wxPyEndAllowThreads(__tstate);
43440 if (PyErr_Occurred()) SWIG_fail;
43441 }
43442 {
43443 resultobj = wxPyMake_wxObject(result, (bool)0);
43444 }
43445 return resultobj;
43446 fail:
43447 return NULL;
43448 }
43449
43450
43451 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43452 PyObject *resultobj = 0;
43453 wxMenu *arg1 = (wxMenu *) 0 ;
43454 int arg2 ;
43455 bool arg3 ;
43456 void *argp1 = 0 ;
43457 int res1 = 0 ;
43458 int val2 ;
43459 int ecode2 = 0 ;
43460 bool val3 ;
43461 int ecode3 = 0 ;
43462 PyObject * obj0 = 0 ;
43463 PyObject * obj1 = 0 ;
43464 PyObject * obj2 = 0 ;
43465 char * kwnames[] = {
43466 (char *) "self",(char *) "id",(char *) "enable", NULL
43467 };
43468
43469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43471 if (!SWIG_IsOK(res1)) {
43472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
43473 }
43474 arg1 = reinterpret_cast< wxMenu * >(argp1);
43475 ecode2 = SWIG_AsVal_int(obj1, &val2);
43476 if (!SWIG_IsOK(ecode2)) {
43477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
43478 }
43479 arg2 = static_cast< int >(val2);
43480 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43481 if (!SWIG_IsOK(ecode3)) {
43482 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
43483 }
43484 arg3 = static_cast< bool >(val3);
43485 {
43486 PyThreadState* __tstate = wxPyBeginAllowThreads();
43487 (arg1)->Enable(arg2,arg3);
43488 wxPyEndAllowThreads(__tstate);
43489 if (PyErr_Occurred()) SWIG_fail;
43490 }
43491 resultobj = SWIG_Py_Void();
43492 return resultobj;
43493 fail:
43494 return NULL;
43495 }
43496
43497
43498 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43499 PyObject *resultobj = 0;
43500 wxMenu *arg1 = (wxMenu *) 0 ;
43501 int arg2 ;
43502 bool result;
43503 void *argp1 = 0 ;
43504 int res1 = 0 ;
43505 int val2 ;
43506 int ecode2 = 0 ;
43507 PyObject * obj0 = 0 ;
43508 PyObject * obj1 = 0 ;
43509 char * kwnames[] = {
43510 (char *) "self",(char *) "id", NULL
43511 };
43512
43513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",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_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
43517 }
43518 arg1 = reinterpret_cast< wxMenu * >(argp1);
43519 ecode2 = SWIG_AsVal_int(obj1, &val2);
43520 if (!SWIG_IsOK(ecode2)) {
43521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
43522 }
43523 arg2 = static_cast< int >(val2);
43524 {
43525 PyThreadState* __tstate = wxPyBeginAllowThreads();
43526 result = (bool)((wxMenu const *)arg1)->IsEnabled(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_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43540 PyObject *resultobj = 0;
43541 wxMenu *arg1 = (wxMenu *) 0 ;
43542 int arg2 ;
43543 bool arg3 ;
43544 void *argp1 = 0 ;
43545 int res1 = 0 ;
43546 int val2 ;
43547 int ecode2 = 0 ;
43548 bool val3 ;
43549 int ecode3 = 0 ;
43550 PyObject * obj0 = 0 ;
43551 PyObject * obj1 = 0 ;
43552 PyObject * obj2 = 0 ;
43553 char * kwnames[] = {
43554 (char *) "self",(char *) "id",(char *) "check", NULL
43555 };
43556
43557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43559 if (!SWIG_IsOK(res1)) {
43560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
43561 }
43562 arg1 = reinterpret_cast< wxMenu * >(argp1);
43563 ecode2 = SWIG_AsVal_int(obj1, &val2);
43564 if (!SWIG_IsOK(ecode2)) {
43565 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
43566 }
43567 arg2 = static_cast< int >(val2);
43568 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43569 if (!SWIG_IsOK(ecode3)) {
43570 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
43571 }
43572 arg3 = static_cast< bool >(val3);
43573 {
43574 PyThreadState* __tstate = wxPyBeginAllowThreads();
43575 (arg1)->Check(arg2,arg3);
43576 wxPyEndAllowThreads(__tstate);
43577 if (PyErr_Occurred()) SWIG_fail;
43578 }
43579 resultobj = SWIG_Py_Void();
43580 return resultobj;
43581 fail:
43582 return NULL;
43583 }
43584
43585
43586 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43587 PyObject *resultobj = 0;
43588 wxMenu *arg1 = (wxMenu *) 0 ;
43589 int arg2 ;
43590 bool result;
43591 void *argp1 = 0 ;
43592 int res1 = 0 ;
43593 int val2 ;
43594 int ecode2 = 0 ;
43595 PyObject * obj0 = 0 ;
43596 PyObject * obj1 = 0 ;
43597 char * kwnames[] = {
43598 (char *) "self",(char *) "id", NULL
43599 };
43600
43601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
43602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43603 if (!SWIG_IsOK(res1)) {
43604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
43605 }
43606 arg1 = reinterpret_cast< wxMenu * >(argp1);
43607 ecode2 = SWIG_AsVal_int(obj1, &val2);
43608 if (!SWIG_IsOK(ecode2)) {
43609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
43610 }
43611 arg2 = static_cast< int >(val2);
43612 {
43613 PyThreadState* __tstate = wxPyBeginAllowThreads();
43614 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
43615 wxPyEndAllowThreads(__tstate);
43616 if (PyErr_Occurred()) SWIG_fail;
43617 }
43618 {
43619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43620 }
43621 return resultobj;
43622 fail:
43623 return NULL;
43624 }
43625
43626
43627 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43628 PyObject *resultobj = 0;
43629 wxMenu *arg1 = (wxMenu *) 0 ;
43630 int arg2 ;
43631 wxString *arg3 = 0 ;
43632 void *argp1 = 0 ;
43633 int res1 = 0 ;
43634 int val2 ;
43635 int ecode2 = 0 ;
43636 bool temp3 = false ;
43637 PyObject * obj0 = 0 ;
43638 PyObject * obj1 = 0 ;
43639 PyObject * obj2 = 0 ;
43640 char * kwnames[] = {
43641 (char *) "self",(char *) "id",(char *) "label", NULL
43642 };
43643
43644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43646 if (!SWIG_IsOK(res1)) {
43647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
43648 }
43649 arg1 = reinterpret_cast< wxMenu * >(argp1);
43650 ecode2 = SWIG_AsVal_int(obj1, &val2);
43651 if (!SWIG_IsOK(ecode2)) {
43652 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
43653 }
43654 arg2 = static_cast< int >(val2);
43655 {
43656 arg3 = wxString_in_helper(obj2);
43657 if (arg3 == NULL) SWIG_fail;
43658 temp3 = true;
43659 }
43660 {
43661 PyThreadState* __tstate = wxPyBeginAllowThreads();
43662 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
43663 wxPyEndAllowThreads(__tstate);
43664 if (PyErr_Occurred()) SWIG_fail;
43665 }
43666 resultobj = SWIG_Py_Void();
43667 {
43668 if (temp3)
43669 delete arg3;
43670 }
43671 return resultobj;
43672 fail:
43673 {
43674 if (temp3)
43675 delete arg3;
43676 }
43677 return NULL;
43678 }
43679
43680
43681 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43682 PyObject *resultobj = 0;
43683 wxMenu *arg1 = (wxMenu *) 0 ;
43684 int arg2 ;
43685 wxString result;
43686 void *argp1 = 0 ;
43687 int res1 = 0 ;
43688 int val2 ;
43689 int ecode2 = 0 ;
43690 PyObject * obj0 = 0 ;
43691 PyObject * obj1 = 0 ;
43692 char * kwnames[] = {
43693 (char *) "self",(char *) "id", NULL
43694 };
43695
43696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
43697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43698 if (!SWIG_IsOK(res1)) {
43699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
43700 }
43701 arg1 = reinterpret_cast< wxMenu * >(argp1);
43702 ecode2 = SWIG_AsVal_int(obj1, &val2);
43703 if (!SWIG_IsOK(ecode2)) {
43704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
43705 }
43706 arg2 = static_cast< int >(val2);
43707 {
43708 PyThreadState* __tstate = wxPyBeginAllowThreads();
43709 result = ((wxMenu const *)arg1)->GetLabel(arg2);
43710 wxPyEndAllowThreads(__tstate);
43711 if (PyErr_Occurred()) SWIG_fail;
43712 }
43713 {
43714 #if wxUSE_UNICODE
43715 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43716 #else
43717 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43718 #endif
43719 }
43720 return resultobj;
43721 fail:
43722 return NULL;
43723 }
43724
43725
43726 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43727 PyObject *resultobj = 0;
43728 wxMenu *arg1 = (wxMenu *) 0 ;
43729 int arg2 ;
43730 wxString *arg3 = 0 ;
43731 void *argp1 = 0 ;
43732 int res1 = 0 ;
43733 int val2 ;
43734 int ecode2 = 0 ;
43735 bool temp3 = false ;
43736 PyObject * obj0 = 0 ;
43737 PyObject * obj1 = 0 ;
43738 PyObject * obj2 = 0 ;
43739 char * kwnames[] = {
43740 (char *) "self",(char *) "id",(char *) "helpString", NULL
43741 };
43742
43743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43745 if (!SWIG_IsOK(res1)) {
43746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
43747 }
43748 arg1 = reinterpret_cast< wxMenu * >(argp1);
43749 ecode2 = SWIG_AsVal_int(obj1, &val2);
43750 if (!SWIG_IsOK(ecode2)) {
43751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
43752 }
43753 arg2 = static_cast< int >(val2);
43754 {
43755 arg3 = wxString_in_helper(obj2);
43756 if (arg3 == NULL) SWIG_fail;
43757 temp3 = true;
43758 }
43759 {
43760 PyThreadState* __tstate = wxPyBeginAllowThreads();
43761 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
43762 wxPyEndAllowThreads(__tstate);
43763 if (PyErr_Occurred()) SWIG_fail;
43764 }
43765 resultobj = SWIG_Py_Void();
43766 {
43767 if (temp3)
43768 delete arg3;
43769 }
43770 return resultobj;
43771 fail:
43772 {
43773 if (temp3)
43774 delete arg3;
43775 }
43776 return NULL;
43777 }
43778
43779
43780 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43781 PyObject *resultobj = 0;
43782 wxMenu *arg1 = (wxMenu *) 0 ;
43783 int arg2 ;
43784 wxString result;
43785 void *argp1 = 0 ;
43786 int res1 = 0 ;
43787 int val2 ;
43788 int ecode2 = 0 ;
43789 PyObject * obj0 = 0 ;
43790 PyObject * obj1 = 0 ;
43791 char * kwnames[] = {
43792 (char *) "self",(char *) "id", NULL
43793 };
43794
43795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
43796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43797 if (!SWIG_IsOK(res1)) {
43798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
43799 }
43800 arg1 = reinterpret_cast< wxMenu * >(argp1);
43801 ecode2 = SWIG_AsVal_int(obj1, &val2);
43802 if (!SWIG_IsOK(ecode2)) {
43803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
43804 }
43805 arg2 = static_cast< int >(val2);
43806 {
43807 PyThreadState* __tstate = wxPyBeginAllowThreads();
43808 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
43809 wxPyEndAllowThreads(__tstate);
43810 if (PyErr_Occurred()) SWIG_fail;
43811 }
43812 {
43813 #if wxUSE_UNICODE
43814 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43815 #else
43816 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43817 #endif
43818 }
43819 return resultobj;
43820 fail:
43821 return NULL;
43822 }
43823
43824
43825 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43826 PyObject *resultobj = 0;
43827 wxMenu *arg1 = (wxMenu *) 0 ;
43828 wxString *arg2 = 0 ;
43829 void *argp1 = 0 ;
43830 int res1 = 0 ;
43831 bool temp2 = false ;
43832 PyObject * obj0 = 0 ;
43833 PyObject * obj1 = 0 ;
43834 char * kwnames[] = {
43835 (char *) "self",(char *) "title", NULL
43836 };
43837
43838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
43839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43840 if (!SWIG_IsOK(res1)) {
43841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
43842 }
43843 arg1 = reinterpret_cast< wxMenu * >(argp1);
43844 {
43845 arg2 = wxString_in_helper(obj1);
43846 if (arg2 == NULL) SWIG_fail;
43847 temp2 = true;
43848 }
43849 {
43850 PyThreadState* __tstate = wxPyBeginAllowThreads();
43851 (arg1)->SetTitle((wxString const &)*arg2);
43852 wxPyEndAllowThreads(__tstate);
43853 if (PyErr_Occurred()) SWIG_fail;
43854 }
43855 resultobj = SWIG_Py_Void();
43856 {
43857 if (temp2)
43858 delete arg2;
43859 }
43860 return resultobj;
43861 fail:
43862 {
43863 if (temp2)
43864 delete arg2;
43865 }
43866 return NULL;
43867 }
43868
43869
43870 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43871 PyObject *resultobj = 0;
43872 wxMenu *arg1 = (wxMenu *) 0 ;
43873 wxString result;
43874 void *argp1 = 0 ;
43875 int res1 = 0 ;
43876 PyObject *swig_obj[1] ;
43877
43878 if (!args) SWIG_fail;
43879 swig_obj[0] = args;
43880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43881 if (!SWIG_IsOK(res1)) {
43882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
43883 }
43884 arg1 = reinterpret_cast< wxMenu * >(argp1);
43885 {
43886 PyThreadState* __tstate = wxPyBeginAllowThreads();
43887 result = ((wxMenu const *)arg1)->GetTitle();
43888 wxPyEndAllowThreads(__tstate);
43889 if (PyErr_Occurred()) SWIG_fail;
43890 }
43891 {
43892 #if wxUSE_UNICODE
43893 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43894 #else
43895 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43896 #endif
43897 }
43898 return resultobj;
43899 fail:
43900 return NULL;
43901 }
43902
43903
43904 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43905 PyObject *resultobj = 0;
43906 wxMenu *arg1 = (wxMenu *) 0 ;
43907 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
43908 void *argp1 = 0 ;
43909 int res1 = 0 ;
43910 void *argp2 = 0 ;
43911 int res2 = 0 ;
43912 PyObject * obj0 = 0 ;
43913 PyObject * obj1 = 0 ;
43914 char * kwnames[] = {
43915 (char *) "self",(char *) "handler", NULL
43916 };
43917
43918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
43919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43920 if (!SWIG_IsOK(res1)) {
43921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
43922 }
43923 arg1 = reinterpret_cast< wxMenu * >(argp1);
43924 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
43925 if (!SWIG_IsOK(res2)) {
43926 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
43927 }
43928 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
43929 {
43930 PyThreadState* __tstate = wxPyBeginAllowThreads();
43931 (arg1)->SetEventHandler(arg2);
43932 wxPyEndAllowThreads(__tstate);
43933 if (PyErr_Occurred()) SWIG_fail;
43934 }
43935 resultobj = SWIG_Py_Void();
43936 return resultobj;
43937 fail:
43938 return NULL;
43939 }
43940
43941
43942 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43943 PyObject *resultobj = 0;
43944 wxMenu *arg1 = (wxMenu *) 0 ;
43945 wxEvtHandler *result = 0 ;
43946 void *argp1 = 0 ;
43947 int res1 = 0 ;
43948 PyObject *swig_obj[1] ;
43949
43950 if (!args) SWIG_fail;
43951 swig_obj[0] = args;
43952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43953 if (!SWIG_IsOK(res1)) {
43954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
43955 }
43956 arg1 = reinterpret_cast< wxMenu * >(argp1);
43957 {
43958 PyThreadState* __tstate = wxPyBeginAllowThreads();
43959 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
43960 wxPyEndAllowThreads(__tstate);
43961 if (PyErr_Occurred()) SWIG_fail;
43962 }
43963 {
43964 resultobj = wxPyMake_wxObject(result, 0);
43965 }
43966 return resultobj;
43967 fail:
43968 return NULL;
43969 }
43970
43971
43972 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43973 PyObject *resultobj = 0;
43974 wxMenu *arg1 = (wxMenu *) 0 ;
43975 wxWindow *arg2 = (wxWindow *) 0 ;
43976 void *argp1 = 0 ;
43977 int res1 = 0 ;
43978 void *argp2 = 0 ;
43979 int res2 = 0 ;
43980 PyObject * obj0 = 0 ;
43981 PyObject * obj1 = 0 ;
43982 char * kwnames[] = {
43983 (char *) "self",(char *) "win", NULL
43984 };
43985
43986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
43987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43988 if (!SWIG_IsOK(res1)) {
43989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
43990 }
43991 arg1 = reinterpret_cast< wxMenu * >(argp1);
43992 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
43993 if (!SWIG_IsOK(res2)) {
43994 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
43995 }
43996 arg2 = reinterpret_cast< wxWindow * >(argp2);
43997 {
43998 PyThreadState* __tstate = wxPyBeginAllowThreads();
43999 (arg1)->SetInvokingWindow(arg2);
44000 wxPyEndAllowThreads(__tstate);
44001 if (PyErr_Occurred()) SWIG_fail;
44002 }
44003 resultobj = SWIG_Py_Void();
44004 return resultobj;
44005 fail:
44006 return NULL;
44007 }
44008
44009
44010 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44011 PyObject *resultobj = 0;
44012 wxMenu *arg1 = (wxMenu *) 0 ;
44013 wxWindow *result = 0 ;
44014 void *argp1 = 0 ;
44015 int res1 = 0 ;
44016 PyObject *swig_obj[1] ;
44017
44018 if (!args) SWIG_fail;
44019 swig_obj[0] = args;
44020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44021 if (!SWIG_IsOK(res1)) {
44022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
44023 }
44024 arg1 = reinterpret_cast< wxMenu * >(argp1);
44025 {
44026 PyThreadState* __tstate = wxPyBeginAllowThreads();
44027 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
44028 wxPyEndAllowThreads(__tstate);
44029 if (PyErr_Occurred()) SWIG_fail;
44030 }
44031 {
44032 resultobj = wxPyMake_wxObject(result, 0);
44033 }
44034 return resultobj;
44035 fail:
44036 return NULL;
44037 }
44038
44039
44040 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44041 PyObject *resultobj = 0;
44042 wxMenu *arg1 = (wxMenu *) 0 ;
44043 long result;
44044 void *argp1 = 0 ;
44045 int res1 = 0 ;
44046 PyObject *swig_obj[1] ;
44047
44048 if (!args) SWIG_fail;
44049 swig_obj[0] = args;
44050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44051 if (!SWIG_IsOK(res1)) {
44052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44053 }
44054 arg1 = reinterpret_cast< wxMenu * >(argp1);
44055 {
44056 PyThreadState* __tstate = wxPyBeginAllowThreads();
44057 result = (long)((wxMenu const *)arg1)->GetStyle();
44058 wxPyEndAllowThreads(__tstate);
44059 if (PyErr_Occurred()) SWIG_fail;
44060 }
44061 resultobj = SWIG_From_long(static_cast< long >(result));
44062 return resultobj;
44063 fail:
44064 return NULL;
44065 }
44066
44067
44068 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44069 PyObject *resultobj = 0;
44070 wxMenu *arg1 = (wxMenu *) 0 ;
44071 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
44072 void *argp1 = 0 ;
44073 int res1 = 0 ;
44074 void *argp2 = 0 ;
44075 int res2 = 0 ;
44076 PyObject * obj0 = 0 ;
44077 PyObject * obj1 = 0 ;
44078 char * kwnames[] = {
44079 (char *) "self",(char *) "source", NULL
44080 };
44081
44082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
44083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44084 if (!SWIG_IsOK(res1)) {
44085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
44086 }
44087 arg1 = reinterpret_cast< wxMenu * >(argp1);
44088 if (obj1) {
44089 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44090 if (!SWIG_IsOK(res2)) {
44091 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44092 }
44093 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44094 }
44095 {
44096 PyThreadState* __tstate = wxPyBeginAllowThreads();
44097 (arg1)->UpdateUI(arg2);
44098 wxPyEndAllowThreads(__tstate);
44099 if (PyErr_Occurred()) SWIG_fail;
44100 }
44101 resultobj = SWIG_Py_Void();
44102 return resultobj;
44103 fail:
44104 return NULL;
44105 }
44106
44107
44108 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44109 PyObject *resultobj = 0;
44110 wxMenu *arg1 = (wxMenu *) 0 ;
44111 wxMenuBar *result = 0 ;
44112 void *argp1 = 0 ;
44113 int res1 = 0 ;
44114 PyObject *swig_obj[1] ;
44115
44116 if (!args) SWIG_fail;
44117 swig_obj[0] = args;
44118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44119 if (!SWIG_IsOK(res1)) {
44120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
44121 }
44122 arg1 = reinterpret_cast< wxMenu * >(argp1);
44123 {
44124 PyThreadState* __tstate = wxPyBeginAllowThreads();
44125 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
44126 wxPyEndAllowThreads(__tstate);
44127 if (PyErr_Occurred()) SWIG_fail;
44128 }
44129 {
44130 resultobj = wxPyMake_wxObject(result, (bool)0);
44131 }
44132 return resultobj;
44133 fail:
44134 return NULL;
44135 }
44136
44137
44138 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44139 PyObject *resultobj = 0;
44140 wxMenu *arg1 = (wxMenu *) 0 ;
44141 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
44142 void *argp1 = 0 ;
44143 int res1 = 0 ;
44144 void *argp2 = 0 ;
44145 int res2 = 0 ;
44146 PyObject * obj0 = 0 ;
44147 PyObject * obj1 = 0 ;
44148 char * kwnames[] = {
44149 (char *) "self",(char *) "menubar", NULL
44150 };
44151
44152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
44153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44154 if (!SWIG_IsOK(res1)) {
44155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
44156 }
44157 arg1 = reinterpret_cast< wxMenu * >(argp1);
44158 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
44159 if (!SWIG_IsOK(res2)) {
44160 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
44161 }
44162 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
44163 {
44164 PyThreadState* __tstate = wxPyBeginAllowThreads();
44165 (arg1)->Attach(arg2);
44166 wxPyEndAllowThreads(__tstate);
44167 if (PyErr_Occurred()) SWIG_fail;
44168 }
44169 resultobj = SWIG_Py_Void();
44170 return resultobj;
44171 fail:
44172 return NULL;
44173 }
44174
44175
44176 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44177 PyObject *resultobj = 0;
44178 wxMenu *arg1 = (wxMenu *) 0 ;
44179 void *argp1 = 0 ;
44180 int res1 = 0 ;
44181 PyObject *swig_obj[1] ;
44182
44183 if (!args) SWIG_fail;
44184 swig_obj[0] = args;
44185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44186 if (!SWIG_IsOK(res1)) {
44187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
44188 }
44189 arg1 = reinterpret_cast< wxMenu * >(argp1);
44190 {
44191 PyThreadState* __tstate = wxPyBeginAllowThreads();
44192 (arg1)->Detach();
44193 wxPyEndAllowThreads(__tstate);
44194 if (PyErr_Occurred()) SWIG_fail;
44195 }
44196 resultobj = SWIG_Py_Void();
44197 return resultobj;
44198 fail:
44199 return NULL;
44200 }
44201
44202
44203 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44204 PyObject *resultobj = 0;
44205 wxMenu *arg1 = (wxMenu *) 0 ;
44206 bool result;
44207 void *argp1 = 0 ;
44208 int res1 = 0 ;
44209 PyObject *swig_obj[1] ;
44210
44211 if (!args) SWIG_fail;
44212 swig_obj[0] = args;
44213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44214 if (!SWIG_IsOK(res1)) {
44215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
44216 }
44217 arg1 = reinterpret_cast< wxMenu * >(argp1);
44218 {
44219 PyThreadState* __tstate = wxPyBeginAllowThreads();
44220 result = (bool)((wxMenu const *)arg1)->IsAttached();
44221 wxPyEndAllowThreads(__tstate);
44222 if (PyErr_Occurred()) SWIG_fail;
44223 }
44224 {
44225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44226 }
44227 return resultobj;
44228 fail:
44229 return NULL;
44230 }
44231
44232
44233 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44234 PyObject *resultobj = 0;
44235 wxMenu *arg1 = (wxMenu *) 0 ;
44236 wxMenu *arg2 = (wxMenu *) 0 ;
44237 void *argp1 = 0 ;
44238 int res1 = 0 ;
44239 void *argp2 = 0 ;
44240 int res2 = 0 ;
44241 PyObject * obj0 = 0 ;
44242 PyObject * obj1 = 0 ;
44243 char * kwnames[] = {
44244 (char *) "self",(char *) "parent", NULL
44245 };
44246
44247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
44248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44249 if (!SWIG_IsOK(res1)) {
44250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
44251 }
44252 arg1 = reinterpret_cast< wxMenu * >(argp1);
44253 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44254 if (!SWIG_IsOK(res2)) {
44255 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
44256 }
44257 arg2 = reinterpret_cast< wxMenu * >(argp2);
44258 {
44259 PyThreadState* __tstate = wxPyBeginAllowThreads();
44260 (arg1)->SetParent(arg2);
44261 wxPyEndAllowThreads(__tstate);
44262 if (PyErr_Occurred()) SWIG_fail;
44263 }
44264 resultobj = SWIG_Py_Void();
44265 return resultobj;
44266 fail:
44267 return NULL;
44268 }
44269
44270
44271 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44272 PyObject *resultobj = 0;
44273 wxMenu *arg1 = (wxMenu *) 0 ;
44274 wxMenu *result = 0 ;
44275 void *argp1 = 0 ;
44276 int res1 = 0 ;
44277 PyObject *swig_obj[1] ;
44278
44279 if (!args) SWIG_fail;
44280 swig_obj[0] = args;
44281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44282 if (!SWIG_IsOK(res1)) {
44283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
44284 }
44285 arg1 = reinterpret_cast< wxMenu * >(argp1);
44286 {
44287 PyThreadState* __tstate = wxPyBeginAllowThreads();
44288 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
44289 wxPyEndAllowThreads(__tstate);
44290 if (PyErr_Occurred()) SWIG_fail;
44291 }
44292 {
44293 resultobj = wxPyMake_wxObject(result, 0);
44294 }
44295 return resultobj;
44296 fail:
44297 return NULL;
44298 }
44299
44300
44301 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44302 PyObject *obj;
44303 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44304 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
44305 return SWIG_Py_Void();
44306 }
44307
44308 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44309 return SWIG_Python_InitShadowInstance(args);
44310 }
44311
44312 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44313 PyObject *resultobj = 0;
44314 long arg1 = (long) 0 ;
44315 wxMenuBar *result = 0 ;
44316 long val1 ;
44317 int ecode1 = 0 ;
44318 PyObject * obj0 = 0 ;
44319 char * kwnames[] = {
44320 (char *) "style", NULL
44321 };
44322
44323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
44324 if (obj0) {
44325 ecode1 = SWIG_AsVal_long(obj0, &val1);
44326 if (!SWIG_IsOK(ecode1)) {
44327 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
44328 }
44329 arg1 = static_cast< long >(val1);
44330 }
44331 {
44332 if (!wxPyCheckForApp()) SWIG_fail;
44333 PyThreadState* __tstate = wxPyBeginAllowThreads();
44334 result = (wxMenuBar *)new wxMenuBar(arg1);
44335 wxPyEndAllowThreads(__tstate);
44336 if (PyErr_Occurred()) SWIG_fail;
44337 }
44338 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
44339 return resultobj;
44340 fail:
44341 return NULL;
44342 }
44343
44344
44345 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44346 PyObject *resultobj = 0;
44347 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44348 wxMenu *arg2 = (wxMenu *) 0 ;
44349 wxString *arg3 = 0 ;
44350 bool result;
44351 void *argp1 = 0 ;
44352 int res1 = 0 ;
44353 void *argp2 = 0 ;
44354 int res2 = 0 ;
44355 bool temp3 = false ;
44356 PyObject * obj0 = 0 ;
44357 PyObject * obj1 = 0 ;
44358 PyObject * obj2 = 0 ;
44359 char * kwnames[] = {
44360 (char *) "self",(char *) "menu",(char *) "title", NULL
44361 };
44362
44363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44365 if (!SWIG_IsOK(res1)) {
44366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44367 }
44368 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44369 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44370 if (!SWIG_IsOK(res2)) {
44371 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
44372 }
44373 arg2 = reinterpret_cast< wxMenu * >(argp2);
44374 {
44375 arg3 = wxString_in_helper(obj2);
44376 if (arg3 == NULL) SWIG_fail;
44377 temp3 = true;
44378 }
44379 {
44380 PyThreadState* __tstate = wxPyBeginAllowThreads();
44381 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
44382 wxPyEndAllowThreads(__tstate);
44383 if (PyErr_Occurred()) SWIG_fail;
44384 }
44385 {
44386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44387 }
44388 {
44389 if (temp3)
44390 delete arg3;
44391 }
44392 return resultobj;
44393 fail:
44394 {
44395 if (temp3)
44396 delete arg3;
44397 }
44398 return NULL;
44399 }
44400
44401
44402 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44403 PyObject *resultobj = 0;
44404 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44405 size_t arg2 ;
44406 wxMenu *arg3 = (wxMenu *) 0 ;
44407 wxString *arg4 = 0 ;
44408 bool result;
44409 void *argp1 = 0 ;
44410 int res1 = 0 ;
44411 size_t val2 ;
44412 int ecode2 = 0 ;
44413 void *argp3 = 0 ;
44414 int res3 = 0 ;
44415 bool temp4 = false ;
44416 PyObject * obj0 = 0 ;
44417 PyObject * obj1 = 0 ;
44418 PyObject * obj2 = 0 ;
44419 PyObject * obj3 = 0 ;
44420 char * kwnames[] = {
44421 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44422 };
44423
44424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44426 if (!SWIG_IsOK(res1)) {
44427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44428 }
44429 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44430 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44431 if (!SWIG_IsOK(ecode2)) {
44432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
44433 }
44434 arg2 = static_cast< size_t >(val2);
44435 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44436 if (!SWIG_IsOK(res3)) {
44437 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
44438 }
44439 arg3 = reinterpret_cast< wxMenu * >(argp3);
44440 {
44441 arg4 = wxString_in_helper(obj3);
44442 if (arg4 == NULL) SWIG_fail;
44443 temp4 = true;
44444 }
44445 {
44446 PyThreadState* __tstate = wxPyBeginAllowThreads();
44447 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
44448 wxPyEndAllowThreads(__tstate);
44449 if (PyErr_Occurred()) SWIG_fail;
44450 }
44451 {
44452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44453 }
44454 {
44455 if (temp4)
44456 delete arg4;
44457 }
44458 return resultobj;
44459 fail:
44460 {
44461 if (temp4)
44462 delete arg4;
44463 }
44464 return NULL;
44465 }
44466
44467
44468 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44469 PyObject *resultobj = 0;
44470 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44471 size_t result;
44472 void *argp1 = 0 ;
44473 int res1 = 0 ;
44474 PyObject *swig_obj[1] ;
44475
44476 if (!args) SWIG_fail;
44477 swig_obj[0] = args;
44478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44479 if (!SWIG_IsOK(res1)) {
44480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44481 }
44482 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44483 {
44484 PyThreadState* __tstate = wxPyBeginAllowThreads();
44485 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
44486 wxPyEndAllowThreads(__tstate);
44487 if (PyErr_Occurred()) SWIG_fail;
44488 }
44489 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
44490 return resultobj;
44491 fail:
44492 return NULL;
44493 }
44494
44495
44496 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44497 PyObject *resultobj = 0;
44498 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44499 size_t arg2 ;
44500 wxMenu *result = 0 ;
44501 void *argp1 = 0 ;
44502 int res1 = 0 ;
44503 size_t val2 ;
44504 int ecode2 = 0 ;
44505 PyObject * obj0 = 0 ;
44506 PyObject * obj1 = 0 ;
44507 char * kwnames[] = {
44508 (char *) "self",(char *) "pos", NULL
44509 };
44510
44511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44513 if (!SWIG_IsOK(res1)) {
44514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44515 }
44516 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44517 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44518 if (!SWIG_IsOK(ecode2)) {
44519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
44520 }
44521 arg2 = static_cast< size_t >(val2);
44522 {
44523 PyThreadState* __tstate = wxPyBeginAllowThreads();
44524 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
44525 wxPyEndAllowThreads(__tstate);
44526 if (PyErr_Occurred()) SWIG_fail;
44527 }
44528 {
44529 resultobj = wxPyMake_wxObject(result, 0);
44530 }
44531 return resultobj;
44532 fail:
44533 return NULL;
44534 }
44535
44536
44537 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44538 PyObject *resultobj = 0;
44539 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44540 size_t arg2 ;
44541 wxMenu *arg3 = (wxMenu *) 0 ;
44542 wxString *arg4 = 0 ;
44543 wxMenu *result = 0 ;
44544 void *argp1 = 0 ;
44545 int res1 = 0 ;
44546 size_t val2 ;
44547 int ecode2 = 0 ;
44548 void *argp3 = 0 ;
44549 int res3 = 0 ;
44550 bool temp4 = false ;
44551 PyObject * obj0 = 0 ;
44552 PyObject * obj1 = 0 ;
44553 PyObject * obj2 = 0 ;
44554 PyObject * obj3 = 0 ;
44555 char * kwnames[] = {
44556 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44557 };
44558
44559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44561 if (!SWIG_IsOK(res1)) {
44562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44563 }
44564 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44565 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44566 if (!SWIG_IsOK(ecode2)) {
44567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
44568 }
44569 arg2 = static_cast< size_t >(val2);
44570 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44571 if (!SWIG_IsOK(res3)) {
44572 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
44573 }
44574 arg3 = reinterpret_cast< wxMenu * >(argp3);
44575 {
44576 arg4 = wxString_in_helper(obj3);
44577 if (arg4 == NULL) SWIG_fail;
44578 temp4 = true;
44579 }
44580 {
44581 PyThreadState* __tstate = wxPyBeginAllowThreads();
44582 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
44583 wxPyEndAllowThreads(__tstate);
44584 if (PyErr_Occurred()) SWIG_fail;
44585 }
44586 {
44587 resultobj = wxPyMake_wxObject(result, 0);
44588 }
44589 {
44590 if (temp4)
44591 delete arg4;
44592 }
44593 return resultobj;
44594 fail:
44595 {
44596 if (temp4)
44597 delete arg4;
44598 }
44599 return NULL;
44600 }
44601
44602
44603 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44604 PyObject *resultobj = 0;
44605 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44606 size_t arg2 ;
44607 wxMenu *result = 0 ;
44608 void *argp1 = 0 ;
44609 int res1 = 0 ;
44610 size_t val2 ;
44611 int ecode2 = 0 ;
44612 PyObject * obj0 = 0 ;
44613 PyObject * obj1 = 0 ;
44614 char * kwnames[] = {
44615 (char *) "self",(char *) "pos", NULL
44616 };
44617
44618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
44619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44620 if (!SWIG_IsOK(res1)) {
44621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44622 }
44623 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44624 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44625 if (!SWIG_IsOK(ecode2)) {
44626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
44627 }
44628 arg2 = static_cast< size_t >(val2);
44629 {
44630 PyThreadState* __tstate = wxPyBeginAllowThreads();
44631 result = (wxMenu *)(arg1)->Remove(arg2);
44632 wxPyEndAllowThreads(__tstate);
44633 if (PyErr_Occurred()) SWIG_fail;
44634 }
44635 {
44636 resultobj = wxPyMake_wxObject(result, 0);
44637 }
44638 return resultobj;
44639 fail:
44640 return NULL;
44641 }
44642
44643
44644 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44645 PyObject *resultobj = 0;
44646 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44647 size_t arg2 ;
44648 bool arg3 ;
44649 void *argp1 = 0 ;
44650 int res1 = 0 ;
44651 size_t val2 ;
44652 int ecode2 = 0 ;
44653 bool val3 ;
44654 int ecode3 = 0 ;
44655 PyObject * obj0 = 0 ;
44656 PyObject * obj1 = 0 ;
44657 PyObject * obj2 = 0 ;
44658 char * kwnames[] = {
44659 (char *) "self",(char *) "pos",(char *) "enable", NULL
44660 };
44661
44662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44664 if (!SWIG_IsOK(res1)) {
44665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44666 }
44667 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44668 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44669 if (!SWIG_IsOK(ecode2)) {
44670 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
44671 }
44672 arg2 = static_cast< size_t >(val2);
44673 ecode3 = SWIG_AsVal_bool(obj2, &val3);
44674 if (!SWIG_IsOK(ecode3)) {
44675 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
44676 }
44677 arg3 = static_cast< bool >(val3);
44678 {
44679 PyThreadState* __tstate = wxPyBeginAllowThreads();
44680 (arg1)->EnableTop(arg2,arg3);
44681 wxPyEndAllowThreads(__tstate);
44682 if (PyErr_Occurred()) SWIG_fail;
44683 }
44684 resultobj = SWIG_Py_Void();
44685 return resultobj;
44686 fail:
44687 return NULL;
44688 }
44689
44690
44691 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44692 PyObject *resultobj = 0;
44693 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44694 size_t arg2 ;
44695 bool result;
44696 void *argp1 = 0 ;
44697 int res1 = 0 ;
44698 size_t val2 ;
44699 int ecode2 = 0 ;
44700 PyObject * obj0 = 0 ;
44701 PyObject * obj1 = 0 ;
44702 char * kwnames[] = {
44703 (char *) "self",(char *) "pos", NULL
44704 };
44705
44706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
44707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44708 if (!SWIG_IsOK(res1)) {
44709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44710 }
44711 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44712 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44713 if (!SWIG_IsOK(ecode2)) {
44714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
44715 }
44716 arg2 = static_cast< size_t >(val2);
44717 {
44718 PyThreadState* __tstate = wxPyBeginAllowThreads();
44719 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
44720 wxPyEndAllowThreads(__tstate);
44721 if (PyErr_Occurred()) SWIG_fail;
44722 }
44723 {
44724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44725 }
44726 return resultobj;
44727 fail:
44728 return NULL;
44729 }
44730
44731
44732 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44733 PyObject *resultobj = 0;
44734 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44735 size_t arg2 ;
44736 wxString *arg3 = 0 ;
44737 void *argp1 = 0 ;
44738 int res1 = 0 ;
44739 size_t val2 ;
44740 int ecode2 = 0 ;
44741 bool temp3 = false ;
44742 PyObject * obj0 = 0 ;
44743 PyObject * obj1 = 0 ;
44744 PyObject * obj2 = 0 ;
44745 char * kwnames[] = {
44746 (char *) "self",(char *) "pos",(char *) "label", NULL
44747 };
44748
44749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44751 if (!SWIG_IsOK(res1)) {
44752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44753 }
44754 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44755 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44756 if (!SWIG_IsOK(ecode2)) {
44757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
44758 }
44759 arg2 = static_cast< size_t >(val2);
44760 {
44761 arg3 = wxString_in_helper(obj2);
44762 if (arg3 == NULL) SWIG_fail;
44763 temp3 = true;
44764 }
44765 {
44766 PyThreadState* __tstate = wxPyBeginAllowThreads();
44767 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
44768 wxPyEndAllowThreads(__tstate);
44769 if (PyErr_Occurred()) SWIG_fail;
44770 }
44771 resultobj = SWIG_Py_Void();
44772 {
44773 if (temp3)
44774 delete arg3;
44775 }
44776 return resultobj;
44777 fail:
44778 {
44779 if (temp3)
44780 delete arg3;
44781 }
44782 return NULL;
44783 }
44784
44785
44786 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44787 PyObject *resultobj = 0;
44788 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44789 size_t arg2 ;
44790 wxString result;
44791 void *argp1 = 0 ;
44792 int res1 = 0 ;
44793 size_t val2 ;
44794 int ecode2 = 0 ;
44795 PyObject * obj0 = 0 ;
44796 PyObject * obj1 = 0 ;
44797 char * kwnames[] = {
44798 (char *) "self",(char *) "pos", NULL
44799 };
44800
44801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
44802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44803 if (!SWIG_IsOK(res1)) {
44804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44805 }
44806 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44807 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44808 if (!SWIG_IsOK(ecode2)) {
44809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
44810 }
44811 arg2 = static_cast< size_t >(val2);
44812 {
44813 PyThreadState* __tstate = wxPyBeginAllowThreads();
44814 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
44815 wxPyEndAllowThreads(__tstate);
44816 if (PyErr_Occurred()) SWIG_fail;
44817 }
44818 {
44819 #if wxUSE_UNICODE
44820 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44821 #else
44822 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44823 #endif
44824 }
44825 return resultobj;
44826 fail:
44827 return NULL;
44828 }
44829
44830
44831 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44832 PyObject *resultobj = 0;
44833 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44834 wxString *arg2 = 0 ;
44835 wxString *arg3 = 0 ;
44836 int result;
44837 void *argp1 = 0 ;
44838 int res1 = 0 ;
44839 bool temp2 = false ;
44840 bool temp3 = false ;
44841 PyObject * obj0 = 0 ;
44842 PyObject * obj1 = 0 ;
44843 PyObject * obj2 = 0 ;
44844 char * kwnames[] = {
44845 (char *) "self",(char *) "menu",(char *) "item", NULL
44846 };
44847
44848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44850 if (!SWIG_IsOK(res1)) {
44851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44852 }
44853 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44854 {
44855 arg2 = wxString_in_helper(obj1);
44856 if (arg2 == NULL) SWIG_fail;
44857 temp2 = true;
44858 }
44859 {
44860 arg3 = wxString_in_helper(obj2);
44861 if (arg3 == NULL) SWIG_fail;
44862 temp3 = true;
44863 }
44864 {
44865 PyThreadState* __tstate = wxPyBeginAllowThreads();
44866 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
44867 wxPyEndAllowThreads(__tstate);
44868 if (PyErr_Occurred()) SWIG_fail;
44869 }
44870 resultobj = SWIG_From_int(static_cast< int >(result));
44871 {
44872 if (temp2)
44873 delete arg2;
44874 }
44875 {
44876 if (temp3)
44877 delete arg3;
44878 }
44879 return resultobj;
44880 fail:
44881 {
44882 if (temp2)
44883 delete arg2;
44884 }
44885 {
44886 if (temp3)
44887 delete arg3;
44888 }
44889 return NULL;
44890 }
44891
44892
44893 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44894 PyObject *resultobj = 0;
44895 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44896 int arg2 ;
44897 wxMenuItem *result = 0 ;
44898 void *argp1 = 0 ;
44899 int res1 = 0 ;
44900 int val2 ;
44901 int ecode2 = 0 ;
44902 PyObject * obj0 = 0 ;
44903 PyObject * obj1 = 0 ;
44904 char * kwnames[] = {
44905 (char *) "self",(char *) "id", NULL
44906 };
44907
44908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
44909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44910 if (!SWIG_IsOK(res1)) {
44911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44912 }
44913 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44914 ecode2 = SWIG_AsVal_int(obj1, &val2);
44915 if (!SWIG_IsOK(ecode2)) {
44916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
44917 }
44918 arg2 = static_cast< int >(val2);
44919 {
44920 PyThreadState* __tstate = wxPyBeginAllowThreads();
44921 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
44922 wxPyEndAllowThreads(__tstate);
44923 if (PyErr_Occurred()) SWIG_fail;
44924 }
44925 {
44926 resultobj = wxPyMake_wxObject(result, (bool)0);
44927 }
44928 return resultobj;
44929 fail:
44930 return NULL;
44931 }
44932
44933
44934 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44935 PyObject *resultobj = 0;
44936 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44937 wxString *arg2 = 0 ;
44938 int result;
44939 void *argp1 = 0 ;
44940 int res1 = 0 ;
44941 bool temp2 = false ;
44942 PyObject * obj0 = 0 ;
44943 PyObject * obj1 = 0 ;
44944 char * kwnames[] = {
44945 (char *) "self",(char *) "title", NULL
44946 };
44947
44948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44950 if (!SWIG_IsOK(res1)) {
44951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44952 }
44953 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44954 {
44955 arg2 = wxString_in_helper(obj1);
44956 if (arg2 == NULL) SWIG_fail;
44957 temp2 = true;
44958 }
44959 {
44960 PyThreadState* __tstate = wxPyBeginAllowThreads();
44961 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
44962 wxPyEndAllowThreads(__tstate);
44963 if (PyErr_Occurred()) SWIG_fail;
44964 }
44965 resultobj = SWIG_From_int(static_cast< int >(result));
44966 {
44967 if (temp2)
44968 delete arg2;
44969 }
44970 return resultobj;
44971 fail:
44972 {
44973 if (temp2)
44974 delete arg2;
44975 }
44976 return NULL;
44977 }
44978
44979
44980 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44981 PyObject *resultobj = 0;
44982 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44983 int arg2 ;
44984 bool arg3 ;
44985 void *argp1 = 0 ;
44986 int res1 = 0 ;
44987 int val2 ;
44988 int ecode2 = 0 ;
44989 bool val3 ;
44990 int ecode3 = 0 ;
44991 PyObject * obj0 = 0 ;
44992 PyObject * obj1 = 0 ;
44993 PyObject * obj2 = 0 ;
44994 char * kwnames[] = {
44995 (char *) "self",(char *) "id",(char *) "enable", NULL
44996 };
44997
44998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45000 if (!SWIG_IsOK(res1)) {
45001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45002 }
45003 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45004 ecode2 = SWIG_AsVal_int(obj1, &val2);
45005 if (!SWIG_IsOK(ecode2)) {
45006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
45007 }
45008 arg2 = static_cast< int >(val2);
45009 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45010 if (!SWIG_IsOK(ecode3)) {
45011 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
45012 }
45013 arg3 = static_cast< bool >(val3);
45014 {
45015 PyThreadState* __tstate = wxPyBeginAllowThreads();
45016 (arg1)->Enable(arg2,arg3);
45017 wxPyEndAllowThreads(__tstate);
45018 if (PyErr_Occurred()) SWIG_fail;
45019 }
45020 resultobj = SWIG_Py_Void();
45021 return resultobj;
45022 fail:
45023 return NULL;
45024 }
45025
45026
45027 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45028 PyObject *resultobj = 0;
45029 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45030 int arg2 ;
45031 bool arg3 ;
45032 void *argp1 = 0 ;
45033 int res1 = 0 ;
45034 int val2 ;
45035 int ecode2 = 0 ;
45036 bool val3 ;
45037 int ecode3 = 0 ;
45038 PyObject * obj0 = 0 ;
45039 PyObject * obj1 = 0 ;
45040 PyObject * obj2 = 0 ;
45041 char * kwnames[] = {
45042 (char *) "self",(char *) "id",(char *) "check", NULL
45043 };
45044
45045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45047 if (!SWIG_IsOK(res1)) {
45048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45049 }
45050 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45051 ecode2 = SWIG_AsVal_int(obj1, &val2);
45052 if (!SWIG_IsOK(ecode2)) {
45053 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
45054 }
45055 arg2 = static_cast< int >(val2);
45056 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45057 if (!SWIG_IsOK(ecode3)) {
45058 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
45059 }
45060 arg3 = static_cast< bool >(val3);
45061 {
45062 PyThreadState* __tstate = wxPyBeginAllowThreads();
45063 (arg1)->Check(arg2,arg3);
45064 wxPyEndAllowThreads(__tstate);
45065 if (PyErr_Occurred()) SWIG_fail;
45066 }
45067 resultobj = SWIG_Py_Void();
45068 return resultobj;
45069 fail:
45070 return NULL;
45071 }
45072
45073
45074 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45075 PyObject *resultobj = 0;
45076 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45077 int arg2 ;
45078 bool result;
45079 void *argp1 = 0 ;
45080 int res1 = 0 ;
45081 int val2 ;
45082 int ecode2 = 0 ;
45083 PyObject * obj0 = 0 ;
45084 PyObject * obj1 = 0 ;
45085 char * kwnames[] = {
45086 (char *) "self",(char *) "id", NULL
45087 };
45088
45089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
45090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45091 if (!SWIG_IsOK(res1)) {
45092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45093 }
45094 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45095 ecode2 = SWIG_AsVal_int(obj1, &val2);
45096 if (!SWIG_IsOK(ecode2)) {
45097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
45098 }
45099 arg2 = static_cast< int >(val2);
45100 {
45101 PyThreadState* __tstate = wxPyBeginAllowThreads();
45102 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
45103 wxPyEndAllowThreads(__tstate);
45104 if (PyErr_Occurred()) SWIG_fail;
45105 }
45106 {
45107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45108 }
45109 return resultobj;
45110 fail:
45111 return NULL;
45112 }
45113
45114
45115 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45116 PyObject *resultobj = 0;
45117 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45118 int arg2 ;
45119 bool result;
45120 void *argp1 = 0 ;
45121 int res1 = 0 ;
45122 int val2 ;
45123 int ecode2 = 0 ;
45124 PyObject * obj0 = 0 ;
45125 PyObject * obj1 = 0 ;
45126 char * kwnames[] = {
45127 (char *) "self",(char *) "id", NULL
45128 };
45129
45130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) 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_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45134 }
45135 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45136 ecode2 = SWIG_AsVal_int(obj1, &val2);
45137 if (!SWIG_IsOK(ecode2)) {
45138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
45139 }
45140 arg2 = static_cast< int >(val2);
45141 {
45142 PyThreadState* __tstate = wxPyBeginAllowThreads();
45143 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
45144 wxPyEndAllowThreads(__tstate);
45145 if (PyErr_Occurred()) SWIG_fail;
45146 }
45147 {
45148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45149 }
45150 return resultobj;
45151 fail:
45152 return NULL;
45153 }
45154
45155
45156 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45157 PyObject *resultobj = 0;
45158 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45159 int arg2 ;
45160 wxString *arg3 = 0 ;
45161 void *argp1 = 0 ;
45162 int res1 = 0 ;
45163 int val2 ;
45164 int ecode2 = 0 ;
45165 bool temp3 = false ;
45166 PyObject * obj0 = 0 ;
45167 PyObject * obj1 = 0 ;
45168 PyObject * obj2 = 0 ;
45169 char * kwnames[] = {
45170 (char *) "self",(char *) "id",(char *) "label", NULL
45171 };
45172
45173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45175 if (!SWIG_IsOK(res1)) {
45176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45177 }
45178 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45179 ecode2 = SWIG_AsVal_int(obj1, &val2);
45180 if (!SWIG_IsOK(ecode2)) {
45181 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
45182 }
45183 arg2 = static_cast< int >(val2);
45184 {
45185 arg3 = wxString_in_helper(obj2);
45186 if (arg3 == NULL) SWIG_fail;
45187 temp3 = true;
45188 }
45189 {
45190 PyThreadState* __tstate = wxPyBeginAllowThreads();
45191 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
45192 wxPyEndAllowThreads(__tstate);
45193 if (PyErr_Occurred()) SWIG_fail;
45194 }
45195 resultobj = SWIG_Py_Void();
45196 {
45197 if (temp3)
45198 delete arg3;
45199 }
45200 return resultobj;
45201 fail:
45202 {
45203 if (temp3)
45204 delete arg3;
45205 }
45206 return NULL;
45207 }
45208
45209
45210 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45211 PyObject *resultobj = 0;
45212 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45213 int arg2 ;
45214 wxString result;
45215 void *argp1 = 0 ;
45216 int res1 = 0 ;
45217 int val2 ;
45218 int ecode2 = 0 ;
45219 PyObject * obj0 = 0 ;
45220 PyObject * obj1 = 0 ;
45221 char * kwnames[] = {
45222 (char *) "self",(char *) "id", NULL
45223 };
45224
45225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
45226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45227 if (!SWIG_IsOK(res1)) {
45228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45229 }
45230 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45231 ecode2 = SWIG_AsVal_int(obj1, &val2);
45232 if (!SWIG_IsOK(ecode2)) {
45233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
45234 }
45235 arg2 = static_cast< int >(val2);
45236 {
45237 PyThreadState* __tstate = wxPyBeginAllowThreads();
45238 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
45239 wxPyEndAllowThreads(__tstate);
45240 if (PyErr_Occurred()) SWIG_fail;
45241 }
45242 {
45243 #if wxUSE_UNICODE
45244 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45245 #else
45246 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45247 #endif
45248 }
45249 return resultobj;
45250 fail:
45251 return NULL;
45252 }
45253
45254
45255 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45256 PyObject *resultobj = 0;
45257 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45258 int arg2 ;
45259 wxString *arg3 = 0 ;
45260 void *argp1 = 0 ;
45261 int res1 = 0 ;
45262 int val2 ;
45263 int ecode2 = 0 ;
45264 bool temp3 = false ;
45265 PyObject * obj0 = 0 ;
45266 PyObject * obj1 = 0 ;
45267 PyObject * obj2 = 0 ;
45268 char * kwnames[] = {
45269 (char *) "self",(char *) "id",(char *) "helpString", NULL
45270 };
45271
45272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45274 if (!SWIG_IsOK(res1)) {
45275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45276 }
45277 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45278 ecode2 = SWIG_AsVal_int(obj1, &val2);
45279 if (!SWIG_IsOK(ecode2)) {
45280 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
45281 }
45282 arg2 = static_cast< int >(val2);
45283 {
45284 arg3 = wxString_in_helper(obj2);
45285 if (arg3 == NULL) SWIG_fail;
45286 temp3 = true;
45287 }
45288 {
45289 PyThreadState* __tstate = wxPyBeginAllowThreads();
45290 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
45291 wxPyEndAllowThreads(__tstate);
45292 if (PyErr_Occurred()) SWIG_fail;
45293 }
45294 resultobj = SWIG_Py_Void();
45295 {
45296 if (temp3)
45297 delete arg3;
45298 }
45299 return resultobj;
45300 fail:
45301 {
45302 if (temp3)
45303 delete arg3;
45304 }
45305 return NULL;
45306 }
45307
45308
45309 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45310 PyObject *resultobj = 0;
45311 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45312 int arg2 ;
45313 wxString result;
45314 void *argp1 = 0 ;
45315 int res1 = 0 ;
45316 int val2 ;
45317 int ecode2 = 0 ;
45318 PyObject * obj0 = 0 ;
45319 PyObject * obj1 = 0 ;
45320 char * kwnames[] = {
45321 (char *) "self",(char *) "id", NULL
45322 };
45323
45324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
45325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45326 if (!SWIG_IsOK(res1)) {
45327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45328 }
45329 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45330 ecode2 = SWIG_AsVal_int(obj1, &val2);
45331 if (!SWIG_IsOK(ecode2)) {
45332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
45333 }
45334 arg2 = static_cast< int >(val2);
45335 {
45336 PyThreadState* __tstate = wxPyBeginAllowThreads();
45337 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
45338 wxPyEndAllowThreads(__tstate);
45339 if (PyErr_Occurred()) SWIG_fail;
45340 }
45341 {
45342 #if wxUSE_UNICODE
45343 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45344 #else
45345 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45346 #endif
45347 }
45348 return resultobj;
45349 fail:
45350 return NULL;
45351 }
45352
45353
45354 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45355 PyObject *resultobj = 0;
45356 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45357 wxFrame *result = 0 ;
45358 void *argp1 = 0 ;
45359 int res1 = 0 ;
45360 PyObject *swig_obj[1] ;
45361
45362 if (!args) SWIG_fail;
45363 swig_obj[0] = args;
45364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45365 if (!SWIG_IsOK(res1)) {
45366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45367 }
45368 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45369 {
45370 PyThreadState* __tstate = wxPyBeginAllowThreads();
45371 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
45372 wxPyEndAllowThreads(__tstate);
45373 if (PyErr_Occurred()) SWIG_fail;
45374 }
45375 {
45376 resultobj = wxPyMake_wxObject(result, (bool)0);
45377 }
45378 return resultobj;
45379 fail:
45380 return NULL;
45381 }
45382
45383
45384 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45385 PyObject *resultobj = 0;
45386 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45387 bool result;
45388 void *argp1 = 0 ;
45389 int res1 = 0 ;
45390 PyObject *swig_obj[1] ;
45391
45392 if (!args) SWIG_fail;
45393 swig_obj[0] = args;
45394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45395 if (!SWIG_IsOK(res1)) {
45396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45397 }
45398 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45399 {
45400 PyThreadState* __tstate = wxPyBeginAllowThreads();
45401 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
45402 wxPyEndAllowThreads(__tstate);
45403 if (PyErr_Occurred()) SWIG_fail;
45404 }
45405 {
45406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45407 }
45408 return resultobj;
45409 fail:
45410 return NULL;
45411 }
45412
45413
45414 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45415 PyObject *resultobj = 0;
45416 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45417 wxFrame *arg2 = (wxFrame *) 0 ;
45418 void *argp1 = 0 ;
45419 int res1 = 0 ;
45420 void *argp2 = 0 ;
45421 int res2 = 0 ;
45422 PyObject * obj0 = 0 ;
45423 PyObject * obj1 = 0 ;
45424 char * kwnames[] = {
45425 (char *) "self",(char *) "frame", NULL
45426 };
45427
45428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
45429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45430 if (!SWIG_IsOK(res1)) {
45431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45432 }
45433 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45434 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
45435 if (!SWIG_IsOK(res2)) {
45436 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
45437 }
45438 arg2 = reinterpret_cast< wxFrame * >(argp2);
45439 {
45440 PyThreadState* __tstate = wxPyBeginAllowThreads();
45441 (arg1)->Attach(arg2);
45442 wxPyEndAllowThreads(__tstate);
45443 if (PyErr_Occurred()) SWIG_fail;
45444 }
45445 resultobj = SWIG_Py_Void();
45446 return resultobj;
45447 fail:
45448 return NULL;
45449 }
45450
45451
45452 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45453 PyObject *resultobj = 0;
45454 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45455 void *argp1 = 0 ;
45456 int res1 = 0 ;
45457 PyObject *swig_obj[1] ;
45458
45459 if (!args) SWIG_fail;
45460 swig_obj[0] = args;
45461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45462 if (!SWIG_IsOK(res1)) {
45463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45464 }
45465 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45466 {
45467 PyThreadState* __tstate = wxPyBeginAllowThreads();
45468 (arg1)->Detach();
45469 wxPyEndAllowThreads(__tstate);
45470 if (PyErr_Occurred()) SWIG_fail;
45471 }
45472 resultobj = SWIG_Py_Void();
45473 return resultobj;
45474 fail:
45475 return NULL;
45476 }
45477
45478
45479 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45480 PyObject *resultobj = 0;
45481 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45482 void *argp1 = 0 ;
45483 int res1 = 0 ;
45484 PyObject *swig_obj[1] ;
45485
45486 if (!args) SWIG_fail;
45487 swig_obj[0] = args;
45488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45489 if (!SWIG_IsOK(res1)) {
45490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45491 }
45492 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45493 {
45494 PyThreadState* __tstate = wxPyBeginAllowThreads();
45495 (arg1)->UpdateMenus();
45496 wxPyEndAllowThreads(__tstate);
45497 if (PyErr_Occurred()) SWIG_fail;
45498 }
45499 resultobj = SWIG_Py_Void();
45500 return resultobj;
45501 fail:
45502 return NULL;
45503 }
45504
45505
45506 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45507 PyObject *resultobj = 0;
45508 bool arg1 ;
45509 bool val1 ;
45510 int ecode1 = 0 ;
45511 PyObject * obj0 = 0 ;
45512 char * kwnames[] = {
45513 (char *) "enable", NULL
45514 };
45515
45516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
45517 ecode1 = SWIG_AsVal_bool(obj0, &val1);
45518 if (!SWIG_IsOK(ecode1)) {
45519 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
45520 }
45521 arg1 = static_cast< bool >(val1);
45522 {
45523 PyThreadState* __tstate = wxPyBeginAllowThreads();
45524 wxMenuBar_SetAutoWindowMenu(arg1);
45525 wxPyEndAllowThreads(__tstate);
45526 if (PyErr_Occurred()) SWIG_fail;
45527 }
45528 resultobj = SWIG_Py_Void();
45529 return resultobj;
45530 fail:
45531 return NULL;
45532 }
45533
45534
45535 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45536 PyObject *resultobj = 0;
45537 bool result;
45538
45539 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
45540 {
45541 PyThreadState* __tstate = wxPyBeginAllowThreads();
45542 result = (bool)wxMenuBar_GetAutoWindowMenu();
45543 wxPyEndAllowThreads(__tstate);
45544 if (PyErr_Occurred()) SWIG_fail;
45545 }
45546 {
45547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45548 }
45549 return resultobj;
45550 fail:
45551 return NULL;
45552 }
45553
45554
45555 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45556 PyObject *obj;
45557 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45558 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
45559 return SWIG_Py_Void();
45560 }
45561
45562 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45563 return SWIG_Python_InitShadowInstance(args);
45564 }
45565
45566 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45567 PyObject *resultobj = 0;
45568 wxMenu *arg1 = (wxMenu *) NULL ;
45569 int arg2 = (int) wxID_ANY ;
45570 wxString const &arg3_defvalue = wxPyEmptyString ;
45571 wxString *arg3 = (wxString *) &arg3_defvalue ;
45572 wxString const &arg4_defvalue = wxPyEmptyString ;
45573 wxString *arg4 = (wxString *) &arg4_defvalue ;
45574 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
45575 wxMenu *arg6 = (wxMenu *) NULL ;
45576 wxMenuItem *result = 0 ;
45577 void *argp1 = 0 ;
45578 int res1 = 0 ;
45579 int val2 ;
45580 int ecode2 = 0 ;
45581 bool temp3 = false ;
45582 bool temp4 = false ;
45583 int val5 ;
45584 int ecode5 = 0 ;
45585 void *argp6 = 0 ;
45586 int res6 = 0 ;
45587 PyObject * obj0 = 0 ;
45588 PyObject * obj1 = 0 ;
45589 PyObject * obj2 = 0 ;
45590 PyObject * obj3 = 0 ;
45591 PyObject * obj4 = 0 ;
45592 PyObject * obj5 = 0 ;
45593 char * kwnames[] = {
45594 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
45595 };
45596
45597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45598 if (obj0) {
45599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45600 if (!SWIG_IsOK(res1)) {
45601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
45602 }
45603 arg1 = reinterpret_cast< wxMenu * >(argp1);
45604 }
45605 if (obj1) {
45606 ecode2 = SWIG_AsVal_int(obj1, &val2);
45607 if (!SWIG_IsOK(ecode2)) {
45608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
45609 }
45610 arg2 = static_cast< int >(val2);
45611 }
45612 if (obj2) {
45613 {
45614 arg3 = wxString_in_helper(obj2);
45615 if (arg3 == NULL) SWIG_fail;
45616 temp3 = true;
45617 }
45618 }
45619 if (obj3) {
45620 {
45621 arg4 = wxString_in_helper(obj3);
45622 if (arg4 == NULL) SWIG_fail;
45623 temp4 = true;
45624 }
45625 }
45626 if (obj4) {
45627 ecode5 = SWIG_AsVal_int(obj4, &val5);
45628 if (!SWIG_IsOK(ecode5)) {
45629 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
45630 }
45631 arg5 = static_cast< wxItemKind >(val5);
45632 }
45633 if (obj5) {
45634 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
45635 if (!SWIG_IsOK(res6)) {
45636 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
45637 }
45638 arg6 = reinterpret_cast< wxMenu * >(argp6);
45639 }
45640 {
45641 PyThreadState* __tstate = wxPyBeginAllowThreads();
45642 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
45643 wxPyEndAllowThreads(__tstate);
45644 if (PyErr_Occurred()) SWIG_fail;
45645 }
45646 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_NEW | 0 );
45647 {
45648 if (temp3)
45649 delete arg3;
45650 }
45651 {
45652 if (temp4)
45653 delete arg4;
45654 }
45655 return resultobj;
45656 fail:
45657 {
45658 if (temp3)
45659 delete arg3;
45660 }
45661 {
45662 if (temp4)
45663 delete arg4;
45664 }
45665 return NULL;
45666 }
45667
45668
45669 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45670 PyObject *resultobj = 0;
45671 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45672 void *argp1 = 0 ;
45673 int res1 = 0 ;
45674 PyObject *swig_obj[1] ;
45675
45676 if (!args) SWIG_fail;
45677 swig_obj[0] = args;
45678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
45679 if (!SWIG_IsOK(res1)) {
45680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45681 }
45682 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45683 {
45684 PyThreadState* __tstate = wxPyBeginAllowThreads();
45685 delete arg1;
45686
45687 wxPyEndAllowThreads(__tstate);
45688 if (PyErr_Occurred()) SWIG_fail;
45689 }
45690 resultobj = SWIG_Py_Void();
45691 return resultobj;
45692 fail:
45693 return NULL;
45694 }
45695
45696
45697 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45698 PyObject *resultobj = 0;
45699 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45700 wxMenu *result = 0 ;
45701 void *argp1 = 0 ;
45702 int res1 = 0 ;
45703 PyObject *swig_obj[1] ;
45704
45705 if (!args) SWIG_fail;
45706 swig_obj[0] = args;
45707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45708 if (!SWIG_IsOK(res1)) {
45709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45710 }
45711 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45712 {
45713 PyThreadState* __tstate = wxPyBeginAllowThreads();
45714 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
45715 wxPyEndAllowThreads(__tstate);
45716 if (PyErr_Occurred()) SWIG_fail;
45717 }
45718 {
45719 resultobj = wxPyMake_wxObject(result, 0);
45720 }
45721 return resultobj;
45722 fail:
45723 return NULL;
45724 }
45725
45726
45727 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45728 PyObject *resultobj = 0;
45729 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45730 wxMenu *arg2 = (wxMenu *) 0 ;
45731 void *argp1 = 0 ;
45732 int res1 = 0 ;
45733 void *argp2 = 0 ;
45734 int res2 = 0 ;
45735 PyObject * obj0 = 0 ;
45736 PyObject * obj1 = 0 ;
45737 char * kwnames[] = {
45738 (char *) "self",(char *) "menu", NULL
45739 };
45740
45741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45743 if (!SWIG_IsOK(res1)) {
45744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45745 }
45746 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45747 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
45748 if (!SWIG_IsOK(res2)) {
45749 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
45750 }
45751 arg2 = reinterpret_cast< wxMenu * >(argp2);
45752 {
45753 PyThreadState* __tstate = wxPyBeginAllowThreads();
45754 (arg1)->SetMenu(arg2);
45755 wxPyEndAllowThreads(__tstate);
45756 if (PyErr_Occurred()) SWIG_fail;
45757 }
45758 resultobj = SWIG_Py_Void();
45759 return resultobj;
45760 fail:
45761 return NULL;
45762 }
45763
45764
45765 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45766 PyObject *resultobj = 0;
45767 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45768 int arg2 ;
45769 void *argp1 = 0 ;
45770 int res1 = 0 ;
45771 int val2 ;
45772 int ecode2 = 0 ;
45773 PyObject * obj0 = 0 ;
45774 PyObject * obj1 = 0 ;
45775 char * kwnames[] = {
45776 (char *) "self",(char *) "id", NULL
45777 };
45778
45779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
45780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45781 if (!SWIG_IsOK(res1)) {
45782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45783 }
45784 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45785 ecode2 = SWIG_AsVal_int(obj1, &val2);
45786 if (!SWIG_IsOK(ecode2)) {
45787 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
45788 }
45789 arg2 = static_cast< int >(val2);
45790 {
45791 PyThreadState* __tstate = wxPyBeginAllowThreads();
45792 (arg1)->SetId(arg2);
45793 wxPyEndAllowThreads(__tstate);
45794 if (PyErr_Occurred()) SWIG_fail;
45795 }
45796 resultobj = SWIG_Py_Void();
45797 return resultobj;
45798 fail:
45799 return NULL;
45800 }
45801
45802
45803 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45804 PyObject *resultobj = 0;
45805 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45806 int result;
45807 void *argp1 = 0 ;
45808 int res1 = 0 ;
45809 PyObject *swig_obj[1] ;
45810
45811 if (!args) SWIG_fail;
45812 swig_obj[0] = args;
45813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45814 if (!SWIG_IsOK(res1)) {
45815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45816 }
45817 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45818 {
45819 PyThreadState* __tstate = wxPyBeginAllowThreads();
45820 result = (int)((wxMenuItem const *)arg1)->GetId();
45821 wxPyEndAllowThreads(__tstate);
45822 if (PyErr_Occurred()) SWIG_fail;
45823 }
45824 resultobj = SWIG_From_int(static_cast< int >(result));
45825 return resultobj;
45826 fail:
45827 return NULL;
45828 }
45829
45830
45831 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45832 PyObject *resultobj = 0;
45833 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45834 bool result;
45835 void *argp1 = 0 ;
45836 int res1 = 0 ;
45837 PyObject *swig_obj[1] ;
45838
45839 if (!args) SWIG_fail;
45840 swig_obj[0] = args;
45841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45842 if (!SWIG_IsOK(res1)) {
45843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45844 }
45845 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45846 {
45847 PyThreadState* __tstate = wxPyBeginAllowThreads();
45848 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
45849 wxPyEndAllowThreads(__tstate);
45850 if (PyErr_Occurred()) SWIG_fail;
45851 }
45852 {
45853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45854 }
45855 return resultobj;
45856 fail:
45857 return NULL;
45858 }
45859
45860
45861 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45862 PyObject *resultobj = 0;
45863 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45864 wxString *arg2 = 0 ;
45865 void *argp1 = 0 ;
45866 int res1 = 0 ;
45867 bool temp2 = false ;
45868 PyObject * obj0 = 0 ;
45869 PyObject * obj1 = 0 ;
45870 char * kwnames[] = {
45871 (char *) "self",(char *) "str", NULL
45872 };
45873
45874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
45875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45876 if (!SWIG_IsOK(res1)) {
45877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45878 }
45879 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45880 {
45881 arg2 = wxString_in_helper(obj1);
45882 if (arg2 == NULL) SWIG_fail;
45883 temp2 = true;
45884 }
45885 {
45886 PyThreadState* __tstate = wxPyBeginAllowThreads();
45887 (arg1)->SetText((wxString const &)*arg2);
45888 wxPyEndAllowThreads(__tstate);
45889 if (PyErr_Occurred()) SWIG_fail;
45890 }
45891 resultobj = SWIG_Py_Void();
45892 {
45893 if (temp2)
45894 delete arg2;
45895 }
45896 return resultobj;
45897 fail:
45898 {
45899 if (temp2)
45900 delete arg2;
45901 }
45902 return NULL;
45903 }
45904
45905
45906 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45907 PyObject *resultobj = 0;
45908 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45909 wxString result;
45910 void *argp1 = 0 ;
45911 int res1 = 0 ;
45912 PyObject *swig_obj[1] ;
45913
45914 if (!args) SWIG_fail;
45915 swig_obj[0] = args;
45916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45917 if (!SWIG_IsOK(res1)) {
45918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45919 }
45920 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45921 {
45922 PyThreadState* __tstate = wxPyBeginAllowThreads();
45923 result = ((wxMenuItem const *)arg1)->GetLabel();
45924 wxPyEndAllowThreads(__tstate);
45925 if (PyErr_Occurred()) SWIG_fail;
45926 }
45927 {
45928 #if wxUSE_UNICODE
45929 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45930 #else
45931 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45932 #endif
45933 }
45934 return resultobj;
45935 fail:
45936 return NULL;
45937 }
45938
45939
45940 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45941 PyObject *resultobj = 0;
45942 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45943 wxString *result = 0 ;
45944 void *argp1 = 0 ;
45945 int res1 = 0 ;
45946 PyObject *swig_obj[1] ;
45947
45948 if (!args) SWIG_fail;
45949 swig_obj[0] = args;
45950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45951 if (!SWIG_IsOK(res1)) {
45952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45953 }
45954 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45955 {
45956 PyThreadState* __tstate = wxPyBeginAllowThreads();
45957 {
45958 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
45959 result = (wxString *) &_result_ref;
45960 }
45961 wxPyEndAllowThreads(__tstate);
45962 if (PyErr_Occurred()) SWIG_fail;
45963 }
45964 {
45965 #if wxUSE_UNICODE
45966 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
45967 #else
45968 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
45969 #endif
45970 }
45971 return resultobj;
45972 fail:
45973 return NULL;
45974 }
45975
45976
45977 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45978 PyObject *resultobj = 0;
45979 wxString *arg1 = 0 ;
45980 wxString result;
45981 bool temp1 = false ;
45982 PyObject * obj0 = 0 ;
45983 char * kwnames[] = {
45984 (char *) "text", NULL
45985 };
45986
45987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
45988 {
45989 arg1 = wxString_in_helper(obj0);
45990 if (arg1 == NULL) SWIG_fail;
45991 temp1 = true;
45992 }
45993 {
45994 PyThreadState* __tstate = wxPyBeginAllowThreads();
45995 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
45996 wxPyEndAllowThreads(__tstate);
45997 if (PyErr_Occurred()) SWIG_fail;
45998 }
45999 {
46000 #if wxUSE_UNICODE
46001 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46002 #else
46003 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46004 #endif
46005 }
46006 {
46007 if (temp1)
46008 delete arg1;
46009 }
46010 return resultobj;
46011 fail:
46012 {
46013 if (temp1)
46014 delete arg1;
46015 }
46016 return NULL;
46017 }
46018
46019
46020 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46021 PyObject *resultobj = 0;
46022 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46023 wxItemKind result;
46024 void *argp1 = 0 ;
46025 int res1 = 0 ;
46026 PyObject *swig_obj[1] ;
46027
46028 if (!args) SWIG_fail;
46029 swig_obj[0] = args;
46030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46031 if (!SWIG_IsOK(res1)) {
46032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46033 }
46034 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46035 {
46036 PyThreadState* __tstate = wxPyBeginAllowThreads();
46037 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
46038 wxPyEndAllowThreads(__tstate);
46039 if (PyErr_Occurred()) SWIG_fail;
46040 }
46041 resultobj = SWIG_From_int(static_cast< int >(result));
46042 return resultobj;
46043 fail:
46044 return NULL;
46045 }
46046
46047
46048 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46049 PyObject *resultobj = 0;
46050 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46051 wxItemKind arg2 ;
46052 void *argp1 = 0 ;
46053 int res1 = 0 ;
46054 int val2 ;
46055 int ecode2 = 0 ;
46056 PyObject * obj0 = 0 ;
46057 PyObject * obj1 = 0 ;
46058 char * kwnames[] = {
46059 (char *) "self",(char *) "kind", NULL
46060 };
46061
46062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
46063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46064 if (!SWIG_IsOK(res1)) {
46065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46066 }
46067 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46068 ecode2 = SWIG_AsVal_int(obj1, &val2);
46069 if (!SWIG_IsOK(ecode2)) {
46070 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
46071 }
46072 arg2 = static_cast< wxItemKind >(val2);
46073 {
46074 PyThreadState* __tstate = wxPyBeginAllowThreads();
46075 (arg1)->SetKind(arg2);
46076 wxPyEndAllowThreads(__tstate);
46077 if (PyErr_Occurred()) SWIG_fail;
46078 }
46079 resultobj = SWIG_Py_Void();
46080 return resultobj;
46081 fail:
46082 return NULL;
46083 }
46084
46085
46086 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46087 PyObject *resultobj = 0;
46088 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46089 bool arg2 ;
46090 void *argp1 = 0 ;
46091 int res1 = 0 ;
46092 bool val2 ;
46093 int ecode2 = 0 ;
46094 PyObject * obj0 = 0 ;
46095 PyObject * obj1 = 0 ;
46096 char * kwnames[] = {
46097 (char *) "self",(char *) "checkable", NULL
46098 };
46099
46100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
46101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46102 if (!SWIG_IsOK(res1)) {
46103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46104 }
46105 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46106 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46107 if (!SWIG_IsOK(ecode2)) {
46108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
46109 }
46110 arg2 = static_cast< bool >(val2);
46111 {
46112 PyThreadState* __tstate = wxPyBeginAllowThreads();
46113 (arg1)->SetCheckable(arg2);
46114 wxPyEndAllowThreads(__tstate);
46115 if (PyErr_Occurred()) SWIG_fail;
46116 }
46117 resultobj = SWIG_Py_Void();
46118 return resultobj;
46119 fail:
46120 return NULL;
46121 }
46122
46123
46124 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46125 PyObject *resultobj = 0;
46126 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46127 bool result;
46128 void *argp1 = 0 ;
46129 int res1 = 0 ;
46130 PyObject *swig_obj[1] ;
46131
46132 if (!args) SWIG_fail;
46133 swig_obj[0] = args;
46134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46135 if (!SWIG_IsOK(res1)) {
46136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46137 }
46138 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46139 {
46140 PyThreadState* __tstate = wxPyBeginAllowThreads();
46141 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
46142 wxPyEndAllowThreads(__tstate);
46143 if (PyErr_Occurred()) SWIG_fail;
46144 }
46145 {
46146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46147 }
46148 return resultobj;
46149 fail:
46150 return NULL;
46151 }
46152
46153
46154 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46155 PyObject *resultobj = 0;
46156 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46157 bool result;
46158 void *argp1 = 0 ;
46159 int res1 = 0 ;
46160 PyObject *swig_obj[1] ;
46161
46162 if (!args) SWIG_fail;
46163 swig_obj[0] = args;
46164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46165 if (!SWIG_IsOK(res1)) {
46166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46167 }
46168 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46169 {
46170 PyThreadState* __tstate = wxPyBeginAllowThreads();
46171 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
46172 wxPyEndAllowThreads(__tstate);
46173 if (PyErr_Occurred()) SWIG_fail;
46174 }
46175 {
46176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46177 }
46178 return resultobj;
46179 fail:
46180 return NULL;
46181 }
46182
46183
46184 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46185 PyObject *resultobj = 0;
46186 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46187 wxMenu *arg2 = (wxMenu *) 0 ;
46188 void *argp1 = 0 ;
46189 int res1 = 0 ;
46190 void *argp2 = 0 ;
46191 int res2 = 0 ;
46192 PyObject * obj0 = 0 ;
46193 PyObject * obj1 = 0 ;
46194 char * kwnames[] = {
46195 (char *) "self",(char *) "menu", NULL
46196 };
46197
46198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
46199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46200 if (!SWIG_IsOK(res1)) {
46201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46202 }
46203 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46204 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
46205 if (!SWIG_IsOK(res2)) {
46206 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46207 }
46208 arg2 = reinterpret_cast< wxMenu * >(argp2);
46209 {
46210 PyThreadState* __tstate = wxPyBeginAllowThreads();
46211 (arg1)->SetSubMenu(arg2);
46212 wxPyEndAllowThreads(__tstate);
46213 if (PyErr_Occurred()) SWIG_fail;
46214 }
46215 resultobj = SWIG_Py_Void();
46216 return resultobj;
46217 fail:
46218 return NULL;
46219 }
46220
46221
46222 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46223 PyObject *resultobj = 0;
46224 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46225 wxMenu *result = 0 ;
46226 void *argp1 = 0 ;
46227 int res1 = 0 ;
46228 PyObject *swig_obj[1] ;
46229
46230 if (!args) SWIG_fail;
46231 swig_obj[0] = args;
46232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46233 if (!SWIG_IsOK(res1)) {
46234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46235 }
46236 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46237 {
46238 PyThreadState* __tstate = wxPyBeginAllowThreads();
46239 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
46240 wxPyEndAllowThreads(__tstate);
46241 if (PyErr_Occurred()) SWIG_fail;
46242 }
46243 {
46244 resultobj = wxPyMake_wxObject(result, 0);
46245 }
46246 return resultobj;
46247 fail:
46248 return NULL;
46249 }
46250
46251
46252 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46253 PyObject *resultobj = 0;
46254 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46255 bool arg2 = (bool) true ;
46256 void *argp1 = 0 ;
46257 int res1 = 0 ;
46258 bool val2 ;
46259 int ecode2 = 0 ;
46260 PyObject * obj0 = 0 ;
46261 PyObject * obj1 = 0 ;
46262 char * kwnames[] = {
46263 (char *) "self",(char *) "enable", NULL
46264 };
46265
46266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
46267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46268 if (!SWIG_IsOK(res1)) {
46269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46270 }
46271 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46272 if (obj1) {
46273 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46274 if (!SWIG_IsOK(ecode2)) {
46275 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
46276 }
46277 arg2 = static_cast< bool >(val2);
46278 }
46279 {
46280 PyThreadState* __tstate = wxPyBeginAllowThreads();
46281 (arg1)->Enable(arg2);
46282 wxPyEndAllowThreads(__tstate);
46283 if (PyErr_Occurred()) SWIG_fail;
46284 }
46285 resultobj = SWIG_Py_Void();
46286 return resultobj;
46287 fail:
46288 return NULL;
46289 }
46290
46291
46292 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46293 PyObject *resultobj = 0;
46294 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46295 bool result;
46296 void *argp1 = 0 ;
46297 int res1 = 0 ;
46298 PyObject *swig_obj[1] ;
46299
46300 if (!args) SWIG_fail;
46301 swig_obj[0] = args;
46302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46303 if (!SWIG_IsOK(res1)) {
46304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46305 }
46306 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46307 {
46308 PyThreadState* __tstate = wxPyBeginAllowThreads();
46309 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
46310 wxPyEndAllowThreads(__tstate);
46311 if (PyErr_Occurred()) SWIG_fail;
46312 }
46313 {
46314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46315 }
46316 return resultobj;
46317 fail:
46318 return NULL;
46319 }
46320
46321
46322 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46323 PyObject *resultobj = 0;
46324 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46325 bool arg2 = (bool) true ;
46326 void *argp1 = 0 ;
46327 int res1 = 0 ;
46328 bool val2 ;
46329 int ecode2 = 0 ;
46330 PyObject * obj0 = 0 ;
46331 PyObject * obj1 = 0 ;
46332 char * kwnames[] = {
46333 (char *) "self",(char *) "check", NULL
46334 };
46335
46336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
46337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46338 if (!SWIG_IsOK(res1)) {
46339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46340 }
46341 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46342 if (obj1) {
46343 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46344 if (!SWIG_IsOK(ecode2)) {
46345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
46346 }
46347 arg2 = static_cast< bool >(val2);
46348 }
46349 {
46350 PyThreadState* __tstate = wxPyBeginAllowThreads();
46351 (arg1)->Check(arg2);
46352 wxPyEndAllowThreads(__tstate);
46353 if (PyErr_Occurred()) SWIG_fail;
46354 }
46355 resultobj = SWIG_Py_Void();
46356 return resultobj;
46357 fail:
46358 return NULL;
46359 }
46360
46361
46362 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46363 PyObject *resultobj = 0;
46364 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46365 bool result;
46366 void *argp1 = 0 ;
46367 int res1 = 0 ;
46368 PyObject *swig_obj[1] ;
46369
46370 if (!args) SWIG_fail;
46371 swig_obj[0] = args;
46372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46373 if (!SWIG_IsOK(res1)) {
46374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46375 }
46376 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46377 {
46378 PyThreadState* __tstate = wxPyBeginAllowThreads();
46379 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
46380 wxPyEndAllowThreads(__tstate);
46381 if (PyErr_Occurred()) SWIG_fail;
46382 }
46383 {
46384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46385 }
46386 return resultobj;
46387 fail:
46388 return NULL;
46389 }
46390
46391
46392 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46393 PyObject *resultobj = 0;
46394 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46395 void *argp1 = 0 ;
46396 int res1 = 0 ;
46397 PyObject *swig_obj[1] ;
46398
46399 if (!args) SWIG_fail;
46400 swig_obj[0] = args;
46401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46402 if (!SWIG_IsOK(res1)) {
46403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46404 }
46405 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46406 {
46407 PyThreadState* __tstate = wxPyBeginAllowThreads();
46408 (arg1)->Toggle();
46409 wxPyEndAllowThreads(__tstate);
46410 if (PyErr_Occurred()) SWIG_fail;
46411 }
46412 resultobj = SWIG_Py_Void();
46413 return resultobj;
46414 fail:
46415 return NULL;
46416 }
46417
46418
46419 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46420 PyObject *resultobj = 0;
46421 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46422 wxString *arg2 = 0 ;
46423 void *argp1 = 0 ;
46424 int res1 = 0 ;
46425 bool temp2 = false ;
46426 PyObject * obj0 = 0 ;
46427 PyObject * obj1 = 0 ;
46428 char * kwnames[] = {
46429 (char *) "self",(char *) "str", NULL
46430 };
46431
46432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
46433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46434 if (!SWIG_IsOK(res1)) {
46435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46436 }
46437 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46438 {
46439 arg2 = wxString_in_helper(obj1);
46440 if (arg2 == NULL) SWIG_fail;
46441 temp2 = true;
46442 }
46443 {
46444 PyThreadState* __tstate = wxPyBeginAllowThreads();
46445 (arg1)->SetHelp((wxString const &)*arg2);
46446 wxPyEndAllowThreads(__tstate);
46447 if (PyErr_Occurred()) SWIG_fail;
46448 }
46449 resultobj = SWIG_Py_Void();
46450 {
46451 if (temp2)
46452 delete arg2;
46453 }
46454 return resultobj;
46455 fail:
46456 {
46457 if (temp2)
46458 delete arg2;
46459 }
46460 return NULL;
46461 }
46462
46463
46464 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46465 PyObject *resultobj = 0;
46466 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46467 wxString *result = 0 ;
46468 void *argp1 = 0 ;
46469 int res1 = 0 ;
46470 PyObject *swig_obj[1] ;
46471
46472 if (!args) SWIG_fail;
46473 swig_obj[0] = args;
46474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46475 if (!SWIG_IsOK(res1)) {
46476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46477 }
46478 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46479 {
46480 PyThreadState* __tstate = wxPyBeginAllowThreads();
46481 {
46482 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
46483 result = (wxString *) &_result_ref;
46484 }
46485 wxPyEndAllowThreads(__tstate);
46486 if (PyErr_Occurred()) SWIG_fail;
46487 }
46488 {
46489 #if wxUSE_UNICODE
46490 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46491 #else
46492 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46493 #endif
46494 }
46495 return resultobj;
46496 fail:
46497 return NULL;
46498 }
46499
46500
46501 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46502 PyObject *resultobj = 0;
46503 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46504 wxAcceleratorEntry *result = 0 ;
46505 void *argp1 = 0 ;
46506 int res1 = 0 ;
46507 PyObject *swig_obj[1] ;
46508
46509 if (!args) SWIG_fail;
46510 swig_obj[0] = args;
46511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46512 if (!SWIG_IsOK(res1)) {
46513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46514 }
46515 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46516 {
46517 PyThreadState* __tstate = wxPyBeginAllowThreads();
46518 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
46519 wxPyEndAllowThreads(__tstate);
46520 if (PyErr_Occurred()) SWIG_fail;
46521 }
46522 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46523 return resultobj;
46524 fail:
46525 return NULL;
46526 }
46527
46528
46529 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46530 PyObject *resultobj = 0;
46531 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46532 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
46533 void *argp1 = 0 ;
46534 int res1 = 0 ;
46535 void *argp2 = 0 ;
46536 int res2 = 0 ;
46537 PyObject * obj0 = 0 ;
46538 PyObject * obj1 = 0 ;
46539 char * kwnames[] = {
46540 (char *) "self",(char *) "accel", NULL
46541 };
46542
46543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
46544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46545 if (!SWIG_IsOK(res1)) {
46546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46547 }
46548 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46549 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46550 if (!SWIG_IsOK(res2)) {
46551 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
46552 }
46553 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
46554 {
46555 PyThreadState* __tstate = wxPyBeginAllowThreads();
46556 (arg1)->SetAccel(arg2);
46557 wxPyEndAllowThreads(__tstate);
46558 if (PyErr_Occurred()) SWIG_fail;
46559 }
46560 resultobj = SWIG_Py_Void();
46561 return resultobj;
46562 fail:
46563 return NULL;
46564 }
46565
46566
46567 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46568 PyObject *resultobj = 0;
46569 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46570 wxBitmap *arg2 = 0 ;
46571 void *argp1 = 0 ;
46572 int res1 = 0 ;
46573 void *argp2 = 0 ;
46574 int res2 = 0 ;
46575 PyObject * obj0 = 0 ;
46576 PyObject * obj1 = 0 ;
46577 char * kwnames[] = {
46578 (char *) "self",(char *) "bitmap", NULL
46579 };
46580
46581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
46582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46583 if (!SWIG_IsOK(res1)) {
46584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46585 }
46586 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46587 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46588 if (!SWIG_IsOK(res2)) {
46589 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46590 }
46591 if (!argp2) {
46592 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46593 }
46594 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46595 {
46596 PyThreadState* __tstate = wxPyBeginAllowThreads();
46597 (arg1)->SetBitmap((wxBitmap const &)*arg2);
46598 wxPyEndAllowThreads(__tstate);
46599 if (PyErr_Occurred()) SWIG_fail;
46600 }
46601 resultobj = SWIG_Py_Void();
46602 return resultobj;
46603 fail:
46604 return NULL;
46605 }
46606
46607
46608 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46609 PyObject *resultobj = 0;
46610 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46611 wxBitmap *result = 0 ;
46612 void *argp1 = 0 ;
46613 int res1 = 0 ;
46614 PyObject *swig_obj[1] ;
46615
46616 if (!args) SWIG_fail;
46617 swig_obj[0] = args;
46618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46619 if (!SWIG_IsOK(res1)) {
46620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46621 }
46622 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46623 {
46624 PyThreadState* __tstate = wxPyBeginAllowThreads();
46625 {
46626 wxBitmap const &_result_ref = (arg1)->GetBitmap();
46627 result = (wxBitmap *) &_result_ref;
46628 }
46629 wxPyEndAllowThreads(__tstate);
46630 if (PyErr_Occurred()) SWIG_fail;
46631 }
46632 {
46633 wxBitmap* resultptr = new wxBitmap(*result);
46634 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
46635 }
46636 return resultobj;
46637 fail:
46638 return NULL;
46639 }
46640
46641
46642 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46643 PyObject *resultobj = 0;
46644 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46645 wxFont *arg2 = 0 ;
46646 void *argp1 = 0 ;
46647 int res1 = 0 ;
46648 void *argp2 = 0 ;
46649 int res2 = 0 ;
46650 PyObject * obj0 = 0 ;
46651 PyObject * obj1 = 0 ;
46652 char * kwnames[] = {
46653 (char *) "self",(char *) "font", NULL
46654 };
46655
46656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
46657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46658 if (!SWIG_IsOK(res1)) {
46659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46660 }
46661 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46662 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
46663 if (!SWIG_IsOK(res2)) {
46664 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46665 }
46666 if (!argp2) {
46667 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46668 }
46669 arg2 = reinterpret_cast< wxFont * >(argp2);
46670 {
46671 PyThreadState* __tstate = wxPyBeginAllowThreads();
46672 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
46673 wxPyEndAllowThreads(__tstate);
46674 if (PyErr_Occurred()) SWIG_fail;
46675 }
46676 resultobj = SWIG_Py_Void();
46677 return resultobj;
46678 fail:
46679 return NULL;
46680 }
46681
46682
46683 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46684 PyObject *resultobj = 0;
46685 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46686 wxFont result;
46687 void *argp1 = 0 ;
46688 int res1 = 0 ;
46689 PyObject *swig_obj[1] ;
46690
46691 if (!args) SWIG_fail;
46692 swig_obj[0] = args;
46693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46694 if (!SWIG_IsOK(res1)) {
46695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46696 }
46697 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46698 {
46699 PyThreadState* __tstate = wxPyBeginAllowThreads();
46700 result = wxMenuItem_GetFont(arg1);
46701 wxPyEndAllowThreads(__tstate);
46702 if (PyErr_Occurred()) SWIG_fail;
46703 }
46704 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
46705 return resultobj;
46706 fail:
46707 return NULL;
46708 }
46709
46710
46711 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46712 PyObject *resultobj = 0;
46713 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46714 wxColour *arg2 = 0 ;
46715 void *argp1 = 0 ;
46716 int res1 = 0 ;
46717 wxColour temp2 ;
46718 PyObject * obj0 = 0 ;
46719 PyObject * obj1 = 0 ;
46720 char * kwnames[] = {
46721 (char *) "self",(char *) "colText", NULL
46722 };
46723
46724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
46725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46726 if (!SWIG_IsOK(res1)) {
46727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46728 }
46729 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46730 {
46731 arg2 = &temp2;
46732 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46733 }
46734 {
46735 PyThreadState* __tstate = wxPyBeginAllowThreads();
46736 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
46737 wxPyEndAllowThreads(__tstate);
46738 if (PyErr_Occurred()) SWIG_fail;
46739 }
46740 resultobj = SWIG_Py_Void();
46741 return resultobj;
46742 fail:
46743 return NULL;
46744 }
46745
46746
46747 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46748 PyObject *resultobj = 0;
46749 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46750 wxColour result;
46751 void *argp1 = 0 ;
46752 int res1 = 0 ;
46753 PyObject *swig_obj[1] ;
46754
46755 if (!args) SWIG_fail;
46756 swig_obj[0] = args;
46757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46758 if (!SWIG_IsOK(res1)) {
46759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46760 }
46761 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46762 {
46763 PyThreadState* __tstate = wxPyBeginAllowThreads();
46764 result = wxMenuItem_GetTextColour(arg1);
46765 wxPyEndAllowThreads(__tstate);
46766 if (PyErr_Occurred()) SWIG_fail;
46767 }
46768 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
46769 return resultobj;
46770 fail:
46771 return NULL;
46772 }
46773
46774
46775 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46776 PyObject *resultobj = 0;
46777 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46778 wxColour *arg2 = 0 ;
46779 void *argp1 = 0 ;
46780 int res1 = 0 ;
46781 wxColour temp2 ;
46782 PyObject * obj0 = 0 ;
46783 PyObject * obj1 = 0 ;
46784 char * kwnames[] = {
46785 (char *) "self",(char *) "colBack", NULL
46786 };
46787
46788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
46789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46790 if (!SWIG_IsOK(res1)) {
46791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46792 }
46793 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46794 {
46795 arg2 = &temp2;
46796 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46797 }
46798 {
46799 PyThreadState* __tstate = wxPyBeginAllowThreads();
46800 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
46801 wxPyEndAllowThreads(__tstate);
46802 if (PyErr_Occurred()) SWIG_fail;
46803 }
46804 resultobj = SWIG_Py_Void();
46805 return resultobj;
46806 fail:
46807 return NULL;
46808 }
46809
46810
46811 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46812 PyObject *resultobj = 0;
46813 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46814 wxColour result;
46815 void *argp1 = 0 ;
46816 int res1 = 0 ;
46817 PyObject *swig_obj[1] ;
46818
46819 if (!args) SWIG_fail;
46820 swig_obj[0] = args;
46821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46822 if (!SWIG_IsOK(res1)) {
46823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46824 }
46825 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46826 {
46827 PyThreadState* __tstate = wxPyBeginAllowThreads();
46828 result = wxMenuItem_GetBackgroundColour(arg1);
46829 wxPyEndAllowThreads(__tstate);
46830 if (PyErr_Occurred()) SWIG_fail;
46831 }
46832 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
46833 return resultobj;
46834 fail:
46835 return NULL;
46836 }
46837
46838
46839 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46840 PyObject *resultobj = 0;
46841 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46842 wxBitmap *arg2 = 0 ;
46843 wxBitmap const &arg3_defvalue = wxNullBitmap ;
46844 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
46845 void *argp1 = 0 ;
46846 int res1 = 0 ;
46847 void *argp2 = 0 ;
46848 int res2 = 0 ;
46849 void *argp3 = 0 ;
46850 int res3 = 0 ;
46851 PyObject * obj0 = 0 ;
46852 PyObject * obj1 = 0 ;
46853 PyObject * obj2 = 0 ;
46854 char * kwnames[] = {
46855 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
46856 };
46857
46858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46860 if (!SWIG_IsOK(res1)) {
46861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46862 }
46863 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46864 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46865 if (!SWIG_IsOK(res2)) {
46866 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46867 }
46868 if (!argp2) {
46869 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46870 }
46871 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46872 if (obj2) {
46873 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
46874 if (!SWIG_IsOK(res3)) {
46875 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
46876 }
46877 if (!argp3) {
46878 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
46879 }
46880 arg3 = reinterpret_cast< wxBitmap * >(argp3);
46881 }
46882 {
46883 PyThreadState* __tstate = wxPyBeginAllowThreads();
46884 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
46885 wxPyEndAllowThreads(__tstate);
46886 if (PyErr_Occurred()) SWIG_fail;
46887 }
46888 resultobj = SWIG_Py_Void();
46889 return resultobj;
46890 fail:
46891 return NULL;
46892 }
46893
46894
46895 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46896 PyObject *resultobj = 0;
46897 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46898 wxBitmap *arg2 = 0 ;
46899 void *argp1 = 0 ;
46900 int res1 = 0 ;
46901 void *argp2 = 0 ;
46902 int res2 = 0 ;
46903 PyObject * obj0 = 0 ;
46904 PyObject * obj1 = 0 ;
46905 char * kwnames[] = {
46906 (char *) "self",(char *) "bmpDisabled", NULL
46907 };
46908
46909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
46910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46911 if (!SWIG_IsOK(res1)) {
46912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46913 }
46914 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46915 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46916 if (!SWIG_IsOK(res2)) {
46917 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46918 }
46919 if (!argp2) {
46920 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46921 }
46922 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46923 {
46924 PyThreadState* __tstate = wxPyBeginAllowThreads();
46925 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
46926 wxPyEndAllowThreads(__tstate);
46927 if (PyErr_Occurred()) SWIG_fail;
46928 }
46929 resultobj = SWIG_Py_Void();
46930 return resultobj;
46931 fail:
46932 return NULL;
46933 }
46934
46935
46936 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46937 PyObject *resultobj = 0;
46938 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46939 wxBitmap *result = 0 ;
46940 void *argp1 = 0 ;
46941 int res1 = 0 ;
46942 PyObject *swig_obj[1] ;
46943
46944 if (!args) SWIG_fail;
46945 swig_obj[0] = args;
46946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46947 if (!SWIG_IsOK(res1)) {
46948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46949 }
46950 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46951 {
46952 PyThreadState* __tstate = wxPyBeginAllowThreads();
46953 {
46954 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
46955 result = (wxBitmap *) &_result_ref;
46956 }
46957 wxPyEndAllowThreads(__tstate);
46958 if (PyErr_Occurred()) SWIG_fail;
46959 }
46960 {
46961 wxBitmap* resultptr = new wxBitmap(*result);
46962 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
46963 }
46964 return resultobj;
46965 fail:
46966 return NULL;
46967 }
46968
46969
46970 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46971 PyObject *resultobj = 0;
46972 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46973 int arg2 ;
46974 void *argp1 = 0 ;
46975 int res1 = 0 ;
46976 int val2 ;
46977 int ecode2 = 0 ;
46978 PyObject * obj0 = 0 ;
46979 PyObject * obj1 = 0 ;
46980 char * kwnames[] = {
46981 (char *) "self",(char *) "nWidth", NULL
46982 };
46983
46984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
46985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46986 if (!SWIG_IsOK(res1)) {
46987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46988 }
46989 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46990 ecode2 = SWIG_AsVal_int(obj1, &val2);
46991 if (!SWIG_IsOK(ecode2)) {
46992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
46993 }
46994 arg2 = static_cast< int >(val2);
46995 {
46996 PyThreadState* __tstate = wxPyBeginAllowThreads();
46997 wxMenuItem_SetMarginWidth(arg1,arg2);
46998 wxPyEndAllowThreads(__tstate);
46999 if (PyErr_Occurred()) SWIG_fail;
47000 }
47001 resultobj = SWIG_Py_Void();
47002 return resultobj;
47003 fail:
47004 return NULL;
47005 }
47006
47007
47008 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47009 PyObject *resultobj = 0;
47010 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47011 int result;
47012 void *argp1 = 0 ;
47013 int res1 = 0 ;
47014 PyObject *swig_obj[1] ;
47015
47016 if (!args) SWIG_fail;
47017 swig_obj[0] = args;
47018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47019 if (!SWIG_IsOK(res1)) {
47020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47021 }
47022 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47023 {
47024 PyThreadState* __tstate = wxPyBeginAllowThreads();
47025 result = (int)wxMenuItem_GetMarginWidth(arg1);
47026 wxPyEndAllowThreads(__tstate);
47027 if (PyErr_Occurred()) SWIG_fail;
47028 }
47029 resultobj = SWIG_From_int(static_cast< int >(result));
47030 return resultobj;
47031 fail:
47032 return NULL;
47033 }
47034
47035
47036 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47037 PyObject *resultobj = 0;
47038 int result;
47039
47040 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
47041 {
47042 PyThreadState* __tstate = wxPyBeginAllowThreads();
47043 result = (int)wxMenuItem_GetDefaultMarginWidth();
47044 wxPyEndAllowThreads(__tstate);
47045 if (PyErr_Occurred()) SWIG_fail;
47046 }
47047 resultobj = SWIG_From_int(static_cast< int >(result));
47048 return resultobj;
47049 fail:
47050 return NULL;
47051 }
47052
47053
47054 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47055 PyObject *resultobj = 0;
47056 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47057 bool result;
47058 void *argp1 = 0 ;
47059 int res1 = 0 ;
47060 PyObject *swig_obj[1] ;
47061
47062 if (!args) SWIG_fail;
47063 swig_obj[0] = args;
47064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47065 if (!SWIG_IsOK(res1)) {
47066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47067 }
47068 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47069 {
47070 PyThreadState* __tstate = wxPyBeginAllowThreads();
47071 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
47072 wxPyEndAllowThreads(__tstate);
47073 if (PyErr_Occurred()) SWIG_fail;
47074 }
47075 {
47076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47077 }
47078 return resultobj;
47079 fail:
47080 return NULL;
47081 }
47082
47083
47084 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47085 PyObject *resultobj = 0;
47086 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47087 bool arg2 = (bool) true ;
47088 void *argp1 = 0 ;
47089 int res1 = 0 ;
47090 bool val2 ;
47091 int ecode2 = 0 ;
47092 PyObject * obj0 = 0 ;
47093 PyObject * obj1 = 0 ;
47094 char * kwnames[] = {
47095 (char *) "self",(char *) "ownerDrawn", NULL
47096 };
47097
47098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
47099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47100 if (!SWIG_IsOK(res1)) {
47101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47102 }
47103 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47104 if (obj1) {
47105 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47106 if (!SWIG_IsOK(ecode2)) {
47107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
47108 }
47109 arg2 = static_cast< bool >(val2);
47110 }
47111 {
47112 PyThreadState* __tstate = wxPyBeginAllowThreads();
47113 wxMenuItem_SetOwnerDrawn(arg1,arg2);
47114 wxPyEndAllowThreads(__tstate);
47115 if (PyErr_Occurred()) SWIG_fail;
47116 }
47117 resultobj = SWIG_Py_Void();
47118 return resultobj;
47119 fail:
47120 return NULL;
47121 }
47122
47123
47124 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47125 PyObject *resultobj = 0;
47126 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47127 void *argp1 = 0 ;
47128 int res1 = 0 ;
47129 PyObject *swig_obj[1] ;
47130
47131 if (!args) SWIG_fail;
47132 swig_obj[0] = args;
47133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47134 if (!SWIG_IsOK(res1)) {
47135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47136 }
47137 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47138 {
47139 PyThreadState* __tstate = wxPyBeginAllowThreads();
47140 wxMenuItem_ResetOwnerDrawn(arg1);
47141 wxPyEndAllowThreads(__tstate);
47142 if (PyErr_Occurred()) SWIG_fail;
47143 }
47144 resultobj = SWIG_Py_Void();
47145 return resultobj;
47146 fail:
47147 return NULL;
47148 }
47149
47150
47151 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47152 PyObject *obj;
47153 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47154 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
47155 return SWIG_Py_Void();
47156 }
47157
47158 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47159 return SWIG_Python_InitShadowInstance(args);
47160 }
47161
47162 SWIGINTERN int ControlNameStr_set(PyObject *) {
47163 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
47164 return 1;
47165 }
47166
47167
47168 SWIGINTERN PyObject *ControlNameStr_get(void) {
47169 PyObject *pyobj = 0;
47170
47171 {
47172 #if wxUSE_UNICODE
47173 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47174 #else
47175 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47176 #endif
47177 }
47178 return pyobj;
47179 }
47180
47181
47182 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47183 PyObject *resultobj = 0;
47184 wxWindow *arg1 = (wxWindow *) 0 ;
47185 int arg2 = (int) -1 ;
47186 wxPoint const &arg3_defvalue = wxDefaultPosition ;
47187 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
47188 wxSize const &arg4_defvalue = wxDefaultSize ;
47189 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
47190 long arg5 = (long) 0 ;
47191 wxValidator const &arg6_defvalue = wxDefaultValidator ;
47192 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
47193 wxString const &arg7_defvalue = wxPyControlNameStr ;
47194 wxString *arg7 = (wxString *) &arg7_defvalue ;
47195 wxControl *result = 0 ;
47196 void *argp1 = 0 ;
47197 int res1 = 0 ;
47198 int val2 ;
47199 int ecode2 = 0 ;
47200 wxPoint temp3 ;
47201 wxSize temp4 ;
47202 long val5 ;
47203 int ecode5 = 0 ;
47204 void *argp6 = 0 ;
47205 int res6 = 0 ;
47206 bool temp7 = false ;
47207 PyObject * obj0 = 0 ;
47208 PyObject * obj1 = 0 ;
47209 PyObject * obj2 = 0 ;
47210 PyObject * obj3 = 0 ;
47211 PyObject * obj4 = 0 ;
47212 PyObject * obj5 = 0 ;
47213 PyObject * obj6 = 0 ;
47214 char * kwnames[] = {
47215 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47216 };
47217
47218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
47220 if (!SWIG_IsOK(res1)) {
47221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
47222 }
47223 arg1 = reinterpret_cast< wxWindow * >(argp1);
47224 if (obj1) {
47225 ecode2 = SWIG_AsVal_int(obj1, &val2);
47226 if (!SWIG_IsOK(ecode2)) {
47227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
47228 }
47229 arg2 = static_cast< int >(val2);
47230 }
47231 if (obj2) {
47232 {
47233 arg3 = &temp3;
47234 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
47235 }
47236 }
47237 if (obj3) {
47238 {
47239 arg4 = &temp4;
47240 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
47241 }
47242 }
47243 if (obj4) {
47244 ecode5 = SWIG_AsVal_long(obj4, &val5);
47245 if (!SWIG_IsOK(ecode5)) {
47246 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
47247 }
47248 arg5 = static_cast< long >(val5);
47249 }
47250 if (obj5) {
47251 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
47252 if (!SWIG_IsOK(res6)) {
47253 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47254 }
47255 if (!argp6) {
47256 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47257 }
47258 arg6 = reinterpret_cast< wxValidator * >(argp6);
47259 }
47260 if (obj6) {
47261 {
47262 arg7 = wxString_in_helper(obj6);
47263 if (arg7 == NULL) SWIG_fail;
47264 temp7 = true;
47265 }
47266 }
47267 {
47268 if (!wxPyCheckForApp()) SWIG_fail;
47269 PyThreadState* __tstate = wxPyBeginAllowThreads();
47270 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
47271 wxPyEndAllowThreads(__tstate);
47272 if (PyErr_Occurred()) SWIG_fail;
47273 }
47274 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
47275 {
47276 if (temp7)
47277 delete arg7;
47278 }
47279 return resultobj;
47280 fail:
47281 {
47282 if (temp7)
47283 delete arg7;
47284 }
47285 return NULL;
47286 }
47287
47288
47289 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47290 PyObject *resultobj = 0;
47291 wxControl *result = 0 ;
47292
47293 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
47294 {
47295 if (!wxPyCheckForApp()) SWIG_fail;
47296 PyThreadState* __tstate = wxPyBeginAllowThreads();
47297 result = (wxControl *)new wxControl();
47298 wxPyEndAllowThreads(__tstate);
47299 if (PyErr_Occurred()) SWIG_fail;
47300 }
47301 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
47302 return resultobj;
47303 fail:
47304 return NULL;
47305 }
47306
47307
47308 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47309 PyObject *resultobj = 0;
47310 wxControl *arg1 = (wxControl *) 0 ;
47311 wxWindow *arg2 = (wxWindow *) 0 ;
47312 int arg3 = (int) -1 ;
47313 wxPoint const &arg4_defvalue = wxDefaultPosition ;
47314 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
47315 wxSize const &arg5_defvalue = wxDefaultSize ;
47316 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
47317 long arg6 = (long) 0 ;
47318 wxValidator const &arg7_defvalue = wxDefaultValidator ;
47319 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
47320 wxString const &arg8_defvalue = wxPyControlNameStr ;
47321 wxString *arg8 = (wxString *) &arg8_defvalue ;
47322 bool result;
47323 void *argp1 = 0 ;
47324 int res1 = 0 ;
47325 void *argp2 = 0 ;
47326 int res2 = 0 ;
47327 int val3 ;
47328 int ecode3 = 0 ;
47329 wxPoint temp4 ;
47330 wxSize temp5 ;
47331 long val6 ;
47332 int ecode6 = 0 ;
47333 void *argp7 = 0 ;
47334 int res7 = 0 ;
47335 bool temp8 = false ;
47336 PyObject * obj0 = 0 ;
47337 PyObject * obj1 = 0 ;
47338 PyObject * obj2 = 0 ;
47339 PyObject * obj3 = 0 ;
47340 PyObject * obj4 = 0 ;
47341 PyObject * obj5 = 0 ;
47342 PyObject * obj6 = 0 ;
47343 PyObject * obj7 = 0 ;
47344 char * kwnames[] = {
47345 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47346 };
47347
47348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
47349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47350 if (!SWIG_IsOK(res1)) {
47351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
47352 }
47353 arg1 = reinterpret_cast< wxControl * >(argp1);
47354 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47355 if (!SWIG_IsOK(res2)) {
47356 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
47357 }
47358 arg2 = reinterpret_cast< wxWindow * >(argp2);
47359 if (obj2) {
47360 ecode3 = SWIG_AsVal_int(obj2, &val3);
47361 if (!SWIG_IsOK(ecode3)) {
47362 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
47363 }
47364 arg3 = static_cast< int >(val3);
47365 }
47366 if (obj3) {
47367 {
47368 arg4 = &temp4;
47369 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
47370 }
47371 }
47372 if (obj4) {
47373 {
47374 arg5 = &temp5;
47375 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
47376 }
47377 }
47378 if (obj5) {
47379 ecode6 = SWIG_AsVal_long(obj5, &val6);
47380 if (!SWIG_IsOK(ecode6)) {
47381 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
47382 }
47383 arg6 = static_cast< long >(val6);
47384 }
47385 if (obj6) {
47386 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
47387 if (!SWIG_IsOK(res7)) {
47388 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47389 }
47390 if (!argp7) {
47391 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47392 }
47393 arg7 = reinterpret_cast< wxValidator * >(argp7);
47394 }
47395 if (obj7) {
47396 {
47397 arg8 = wxString_in_helper(obj7);
47398 if (arg8 == NULL) SWIG_fail;
47399 temp8 = true;
47400 }
47401 }
47402 {
47403 PyThreadState* __tstate = wxPyBeginAllowThreads();
47404 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
47405 wxPyEndAllowThreads(__tstate);
47406 if (PyErr_Occurred()) SWIG_fail;
47407 }
47408 {
47409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47410 }
47411 {
47412 if (temp8)
47413 delete arg8;
47414 }
47415 return resultobj;
47416 fail:
47417 {
47418 if (temp8)
47419 delete arg8;
47420 }
47421 return NULL;
47422 }
47423
47424
47425 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47426 PyObject *resultobj = 0;
47427 wxControl *arg1 = (wxControl *) 0 ;
47428 int result;
47429 void *argp1 = 0 ;
47430 int res1 = 0 ;
47431 PyObject *swig_obj[1] ;
47432
47433 if (!args) SWIG_fail;
47434 swig_obj[0] = args;
47435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47436 if (!SWIG_IsOK(res1)) {
47437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
47438 }
47439 arg1 = reinterpret_cast< wxControl * >(argp1);
47440 {
47441 PyThreadState* __tstate = wxPyBeginAllowThreads();
47442 result = (int)((wxControl const *)arg1)->GetAlignment();
47443 wxPyEndAllowThreads(__tstate);
47444 if (PyErr_Occurred()) SWIG_fail;
47445 }
47446 resultobj = SWIG_From_int(static_cast< int >(result));
47447 return resultobj;
47448 fail:
47449 return NULL;
47450 }
47451
47452
47453 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47454 PyObject *resultobj = 0;
47455 wxControl *arg1 = (wxControl *) 0 ;
47456 wxString result;
47457 void *argp1 = 0 ;
47458 int res1 = 0 ;
47459 PyObject *swig_obj[1] ;
47460
47461 if (!args) SWIG_fail;
47462 swig_obj[0] = args;
47463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47464 if (!SWIG_IsOK(res1)) {
47465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
47466 }
47467 arg1 = reinterpret_cast< wxControl * >(argp1);
47468 {
47469 PyThreadState* __tstate = wxPyBeginAllowThreads();
47470 result = ((wxControl const *)arg1)->GetLabelText();
47471 wxPyEndAllowThreads(__tstate);
47472 if (PyErr_Occurred()) SWIG_fail;
47473 }
47474 {
47475 #if wxUSE_UNICODE
47476 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
47477 #else
47478 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
47479 #endif
47480 }
47481 return resultobj;
47482 fail:
47483 return NULL;
47484 }
47485
47486
47487 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47488 PyObject *resultobj = 0;
47489 wxControl *arg1 = (wxControl *) 0 ;
47490 wxCommandEvent *arg2 = 0 ;
47491 void *argp1 = 0 ;
47492 int res1 = 0 ;
47493 void *argp2 = 0 ;
47494 int res2 = 0 ;
47495 PyObject * obj0 = 0 ;
47496 PyObject * obj1 = 0 ;
47497 char * kwnames[] = {
47498 (char *) "self",(char *) "event", NULL
47499 };
47500
47501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
47502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47503 if (!SWIG_IsOK(res1)) {
47504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
47505 }
47506 arg1 = reinterpret_cast< wxControl * >(argp1);
47507 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
47508 if (!SWIG_IsOK(res2)) {
47509 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47510 }
47511 if (!argp2) {
47512 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47513 }
47514 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
47515 {
47516 PyThreadState* __tstate = wxPyBeginAllowThreads();
47517 (arg1)->Command(*arg2);
47518 wxPyEndAllowThreads(__tstate);
47519 if (PyErr_Occurred()) SWIG_fail;
47520 }
47521 resultobj = SWIG_Py_Void();
47522 return resultobj;
47523 fail:
47524 return NULL;
47525 }
47526
47527
47528 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47529 PyObject *resultobj = 0;
47530 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
47531 SwigValueWrapper<wxVisualAttributes > result;
47532 int val1 ;
47533 int ecode1 = 0 ;
47534 PyObject * obj0 = 0 ;
47535 char * kwnames[] = {
47536 (char *) "variant", NULL
47537 };
47538
47539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
47540 if (obj0) {
47541 ecode1 = SWIG_AsVal_int(obj0, &val1);
47542 if (!SWIG_IsOK(ecode1)) {
47543 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
47544 }
47545 arg1 = static_cast< wxWindowVariant >(val1);
47546 }
47547 {
47548 if (!wxPyCheckForApp()) SWIG_fail;
47549 PyThreadState* __tstate = wxPyBeginAllowThreads();
47550 result = wxControl::GetClassDefaultAttributes(arg1);
47551 wxPyEndAllowThreads(__tstate);
47552 if (PyErr_Occurred()) SWIG_fail;
47553 }
47554 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
47555 return resultobj;
47556 fail:
47557 return NULL;
47558 }
47559
47560
47561 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47562 PyObject *obj;
47563 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47564 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
47565 return SWIG_Py_Void();
47566 }
47567
47568 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47569 return SWIG_Python_InitShadowInstance(args);
47570 }
47571
47572 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47573 PyObject *resultobj = 0;
47574 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47575 wxString *arg2 = 0 ;
47576 PyObject *arg3 = (PyObject *) NULL ;
47577 int result;
47578 void *argp1 = 0 ;
47579 int res1 = 0 ;
47580 bool temp2 = false ;
47581 PyObject * obj0 = 0 ;
47582 PyObject * obj1 = 0 ;
47583 PyObject * obj2 = 0 ;
47584 char * kwnames[] = {
47585 (char *) "self",(char *) "item",(char *) "clientData", NULL
47586 };
47587
47588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47590 if (!SWIG_IsOK(res1)) {
47591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47592 }
47593 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47594 {
47595 arg2 = wxString_in_helper(obj1);
47596 if (arg2 == NULL) SWIG_fail;
47597 temp2 = true;
47598 }
47599 if (obj2) {
47600 arg3 = obj2;
47601 }
47602 {
47603 PyThreadState* __tstate = wxPyBeginAllowThreads();
47604 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
47605 wxPyEndAllowThreads(__tstate);
47606 if (PyErr_Occurred()) SWIG_fail;
47607 }
47608 resultobj = SWIG_From_int(static_cast< int >(result));
47609 {
47610 if (temp2)
47611 delete arg2;
47612 }
47613 return resultobj;
47614 fail:
47615 {
47616 if (temp2)
47617 delete arg2;
47618 }
47619 return NULL;
47620 }
47621
47622
47623 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47624 PyObject *resultobj = 0;
47625 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47626 wxArrayString *arg2 = 0 ;
47627 void *argp1 = 0 ;
47628 int res1 = 0 ;
47629 bool temp2 = false ;
47630 PyObject * obj0 = 0 ;
47631 PyObject * obj1 = 0 ;
47632 char * kwnames[] = {
47633 (char *) "self",(char *) "strings", NULL
47634 };
47635
47636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
47637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47638 if (!SWIG_IsOK(res1)) {
47639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47640 }
47641 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47642 {
47643 if (! PySequence_Check(obj1)) {
47644 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
47645 SWIG_fail;
47646 }
47647 arg2 = new wxArrayString;
47648 temp2 = true;
47649 int i, len=PySequence_Length(obj1);
47650 for (i=0; i<len; i++) {
47651 PyObject* item = PySequence_GetItem(obj1, i);
47652 wxString* s = wxString_in_helper(item);
47653 if (PyErr_Occurred()) SWIG_fail;
47654 arg2->Add(*s);
47655 delete s;
47656 Py_DECREF(item);
47657 }
47658 }
47659 {
47660 PyThreadState* __tstate = wxPyBeginAllowThreads();
47661 (arg1)->Append((wxArrayString const &)*arg2);
47662 wxPyEndAllowThreads(__tstate);
47663 if (PyErr_Occurred()) SWIG_fail;
47664 }
47665 resultobj = SWIG_Py_Void();
47666 {
47667 if (temp2) delete arg2;
47668 }
47669 return resultobj;
47670 fail:
47671 {
47672 if (temp2) delete arg2;
47673 }
47674 return NULL;
47675 }
47676
47677
47678 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47679 PyObject *resultobj = 0;
47680 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47681 wxString *arg2 = 0 ;
47682 unsigned int arg3 ;
47683 PyObject *arg4 = (PyObject *) NULL ;
47684 int result;
47685 void *argp1 = 0 ;
47686 int res1 = 0 ;
47687 bool temp2 = false ;
47688 unsigned int val3 ;
47689 int ecode3 = 0 ;
47690 PyObject * obj0 = 0 ;
47691 PyObject * obj1 = 0 ;
47692 PyObject * obj2 = 0 ;
47693 PyObject * obj3 = 0 ;
47694 char * kwnames[] = {
47695 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
47696 };
47697
47698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47700 if (!SWIG_IsOK(res1)) {
47701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47702 }
47703 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47704 {
47705 arg2 = wxString_in_helper(obj1);
47706 if (arg2 == NULL) SWIG_fail;
47707 temp2 = true;
47708 }
47709 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
47710 if (!SWIG_IsOK(ecode3)) {
47711 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
47712 }
47713 arg3 = static_cast< unsigned int >(val3);
47714 if (obj3) {
47715 arg4 = obj3;
47716 }
47717 {
47718 PyThreadState* __tstate = wxPyBeginAllowThreads();
47719 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
47720 wxPyEndAllowThreads(__tstate);
47721 if (PyErr_Occurred()) SWIG_fail;
47722 }
47723 resultobj = SWIG_From_int(static_cast< int >(result));
47724 {
47725 if (temp2)
47726 delete arg2;
47727 }
47728 return resultobj;
47729 fail:
47730 {
47731 if (temp2)
47732 delete arg2;
47733 }
47734 return NULL;
47735 }
47736
47737
47738 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47739 PyObject *resultobj = 0;
47740 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47741 void *argp1 = 0 ;
47742 int res1 = 0 ;
47743 PyObject *swig_obj[1] ;
47744
47745 if (!args) SWIG_fail;
47746 swig_obj[0] = args;
47747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47748 if (!SWIG_IsOK(res1)) {
47749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47750 }
47751 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47752 {
47753 PyThreadState* __tstate = wxPyBeginAllowThreads();
47754 (arg1)->Clear();
47755 wxPyEndAllowThreads(__tstate);
47756 if (PyErr_Occurred()) SWIG_fail;
47757 }
47758 resultobj = SWIG_Py_Void();
47759 return resultobj;
47760 fail:
47761 return NULL;
47762 }
47763
47764
47765 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47766 PyObject *resultobj = 0;
47767 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47768 unsigned int arg2 ;
47769 void *argp1 = 0 ;
47770 int res1 = 0 ;
47771 unsigned int val2 ;
47772 int ecode2 = 0 ;
47773 PyObject * obj0 = 0 ;
47774 PyObject * obj1 = 0 ;
47775 char * kwnames[] = {
47776 (char *) "self",(char *) "n", NULL
47777 };
47778
47779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
47780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47781 if (!SWIG_IsOK(res1)) {
47782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47783 }
47784 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47785 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47786 if (!SWIG_IsOK(ecode2)) {
47787 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
47788 }
47789 arg2 = static_cast< unsigned int >(val2);
47790 {
47791 PyThreadState* __tstate = wxPyBeginAllowThreads();
47792 (arg1)->Delete(arg2);
47793 wxPyEndAllowThreads(__tstate);
47794 if (PyErr_Occurred()) SWIG_fail;
47795 }
47796 resultobj = SWIG_Py_Void();
47797 return resultobj;
47798 fail:
47799 return NULL;
47800 }
47801
47802
47803 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47804 PyObject *resultobj = 0;
47805 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47806 unsigned int arg2 ;
47807 PyObject *result = 0 ;
47808 void *argp1 = 0 ;
47809 int res1 = 0 ;
47810 unsigned int val2 ;
47811 int ecode2 = 0 ;
47812 PyObject * obj0 = 0 ;
47813 PyObject * obj1 = 0 ;
47814 char * kwnames[] = {
47815 (char *) "self",(char *) "n", NULL
47816 };
47817
47818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
47819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47820 if (!SWIG_IsOK(res1)) {
47821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47822 }
47823 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47824 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47825 if (!SWIG_IsOK(ecode2)) {
47826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
47827 }
47828 arg2 = static_cast< unsigned int >(val2);
47829 {
47830 PyThreadState* __tstate = wxPyBeginAllowThreads();
47831 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
47832 wxPyEndAllowThreads(__tstate);
47833 if (PyErr_Occurred()) SWIG_fail;
47834 }
47835 resultobj = result;
47836 return resultobj;
47837 fail:
47838 return NULL;
47839 }
47840
47841
47842 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47843 PyObject *resultobj = 0;
47844 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47845 unsigned int arg2 ;
47846 PyObject *arg3 = (PyObject *) 0 ;
47847 void *argp1 = 0 ;
47848 int res1 = 0 ;
47849 unsigned int val2 ;
47850 int ecode2 = 0 ;
47851 PyObject * obj0 = 0 ;
47852 PyObject * obj1 = 0 ;
47853 PyObject * obj2 = 0 ;
47854 char * kwnames[] = {
47855 (char *) "self",(char *) "n",(char *) "clientData", NULL
47856 };
47857
47858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47860 if (!SWIG_IsOK(res1)) {
47861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47862 }
47863 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47864 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47865 if (!SWIG_IsOK(ecode2)) {
47866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
47867 }
47868 arg2 = static_cast< unsigned int >(val2);
47869 arg3 = obj2;
47870 {
47871 PyThreadState* __tstate = wxPyBeginAllowThreads();
47872 wxItemContainer_SetClientData(arg1,arg2,arg3);
47873 wxPyEndAllowThreads(__tstate);
47874 if (PyErr_Occurred()) SWIG_fail;
47875 }
47876 resultobj = SWIG_Py_Void();
47877 return resultobj;
47878 fail:
47879 return NULL;
47880 }
47881
47882
47883 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47884 PyObject *resultobj = 0;
47885 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47886 unsigned int result;
47887 void *argp1 = 0 ;
47888 int res1 = 0 ;
47889 PyObject *swig_obj[1] ;
47890
47891 if (!args) SWIG_fail;
47892 swig_obj[0] = args;
47893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47894 if (!SWIG_IsOK(res1)) {
47895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
47896 }
47897 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47898 {
47899 PyThreadState* __tstate = wxPyBeginAllowThreads();
47900 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
47901 wxPyEndAllowThreads(__tstate);
47902 if (PyErr_Occurred()) SWIG_fail;
47903 }
47904 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
47905 return resultobj;
47906 fail:
47907 return NULL;
47908 }
47909
47910
47911 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47912 PyObject *resultobj = 0;
47913 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47914 bool result;
47915 void *argp1 = 0 ;
47916 int res1 = 0 ;
47917 PyObject *swig_obj[1] ;
47918
47919 if (!args) SWIG_fail;
47920 swig_obj[0] = args;
47921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47922 if (!SWIG_IsOK(res1)) {
47923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
47924 }
47925 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47926 {
47927 PyThreadState* __tstate = wxPyBeginAllowThreads();
47928 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
47929 wxPyEndAllowThreads(__tstate);
47930 if (PyErr_Occurred()) SWIG_fail;
47931 }
47932 {
47933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47934 }
47935 return resultobj;
47936 fail:
47937 return NULL;
47938 }
47939
47940
47941 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47942 PyObject *resultobj = 0;
47943 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47944 unsigned int arg2 ;
47945 wxString result;
47946 void *argp1 = 0 ;
47947 int res1 = 0 ;
47948 unsigned int val2 ;
47949 int ecode2 = 0 ;
47950 PyObject * obj0 = 0 ;
47951 PyObject * obj1 = 0 ;
47952 char * kwnames[] = {
47953 (char *) "self",(char *) "n", NULL
47954 };
47955
47956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
47957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47958 if (!SWIG_IsOK(res1)) {
47959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
47960 }
47961 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47962 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47963 if (!SWIG_IsOK(ecode2)) {
47964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
47965 }
47966 arg2 = static_cast< unsigned int >(val2);
47967 {
47968 PyThreadState* __tstate = wxPyBeginAllowThreads();
47969 result = ((wxItemContainer const *)arg1)->GetString(arg2);
47970 wxPyEndAllowThreads(__tstate);
47971 if (PyErr_Occurred()) SWIG_fail;
47972 }
47973 {
47974 #if wxUSE_UNICODE
47975 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
47976 #else
47977 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
47978 #endif
47979 }
47980 return resultobj;
47981 fail:
47982 return NULL;
47983 }
47984
47985
47986 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47987 PyObject *resultobj = 0;
47988 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47989 wxArrayString result;
47990 void *argp1 = 0 ;
47991 int res1 = 0 ;
47992 PyObject *swig_obj[1] ;
47993
47994 if (!args) SWIG_fail;
47995 swig_obj[0] = args;
47996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47997 if (!SWIG_IsOK(res1)) {
47998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
47999 }
48000 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48001 {
48002 PyThreadState* __tstate = wxPyBeginAllowThreads();
48003 result = ((wxItemContainer const *)arg1)->GetStrings();
48004 wxPyEndAllowThreads(__tstate);
48005 if (PyErr_Occurred()) SWIG_fail;
48006 }
48007 {
48008 resultobj = wxArrayString2PyList_helper(result);
48009 }
48010 return resultobj;
48011 fail:
48012 return NULL;
48013 }
48014
48015
48016 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48017 PyObject *resultobj = 0;
48018 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48019 unsigned int arg2 ;
48020 wxString *arg3 = 0 ;
48021 void *argp1 = 0 ;
48022 int res1 = 0 ;
48023 unsigned int val2 ;
48024 int ecode2 = 0 ;
48025 bool temp3 = false ;
48026 PyObject * obj0 = 0 ;
48027 PyObject * obj1 = 0 ;
48028 PyObject * obj2 = 0 ;
48029 char * kwnames[] = {
48030 (char *) "self",(char *) "n",(char *) "s", NULL
48031 };
48032
48033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48035 if (!SWIG_IsOK(res1)) {
48036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48037 }
48038 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48039 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
48040 if (!SWIG_IsOK(ecode2)) {
48041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
48042 }
48043 arg2 = static_cast< unsigned int >(val2);
48044 {
48045 arg3 = wxString_in_helper(obj2);
48046 if (arg3 == NULL) SWIG_fail;
48047 temp3 = true;
48048 }
48049 {
48050 PyThreadState* __tstate = wxPyBeginAllowThreads();
48051 (arg1)->SetString(arg2,(wxString const &)*arg3);
48052 wxPyEndAllowThreads(__tstate);
48053 if (PyErr_Occurred()) SWIG_fail;
48054 }
48055 resultobj = SWIG_Py_Void();
48056 {
48057 if (temp3)
48058 delete arg3;
48059 }
48060 return resultobj;
48061 fail:
48062 {
48063 if (temp3)
48064 delete arg3;
48065 }
48066 return NULL;
48067 }
48068
48069
48070 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48071 PyObject *resultobj = 0;
48072 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48073 wxString *arg2 = 0 ;
48074 int result;
48075 void *argp1 = 0 ;
48076 int res1 = 0 ;
48077 bool temp2 = false ;
48078 PyObject * obj0 = 0 ;
48079 PyObject * obj1 = 0 ;
48080 char * kwnames[] = {
48081 (char *) "self",(char *) "s", NULL
48082 };
48083
48084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
48085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48086 if (!SWIG_IsOK(res1)) {
48087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48088 }
48089 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48090 {
48091 arg2 = wxString_in_helper(obj1);
48092 if (arg2 == NULL) SWIG_fail;
48093 temp2 = true;
48094 }
48095 {
48096 PyThreadState* __tstate = wxPyBeginAllowThreads();
48097 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
48098 wxPyEndAllowThreads(__tstate);
48099 if (PyErr_Occurred()) SWIG_fail;
48100 }
48101 resultobj = SWIG_From_int(static_cast< int >(result));
48102 {
48103 if (temp2)
48104 delete arg2;
48105 }
48106 return resultobj;
48107 fail:
48108 {
48109 if (temp2)
48110 delete arg2;
48111 }
48112 return NULL;
48113 }
48114
48115
48116 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48117 PyObject *resultobj = 0;
48118 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48119 int arg2 ;
48120 void *argp1 = 0 ;
48121 int res1 = 0 ;
48122 int val2 ;
48123 int ecode2 = 0 ;
48124 PyObject * obj0 = 0 ;
48125 PyObject * obj1 = 0 ;
48126 char * kwnames[] = {
48127 (char *) "self",(char *) "n", NULL
48128 };
48129
48130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48132 if (!SWIG_IsOK(res1)) {
48133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48134 }
48135 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48136 ecode2 = SWIG_AsVal_int(obj1, &val2);
48137 if (!SWIG_IsOK(ecode2)) {
48138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
48139 }
48140 arg2 = static_cast< int >(val2);
48141 {
48142 PyThreadState* __tstate = wxPyBeginAllowThreads();
48143 (arg1)->SetSelection(arg2);
48144 wxPyEndAllowThreads(__tstate);
48145 if (PyErr_Occurred()) SWIG_fail;
48146 }
48147 resultobj = SWIG_Py_Void();
48148 return resultobj;
48149 fail:
48150 return NULL;
48151 }
48152
48153
48154 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48155 PyObject *resultobj = 0;
48156 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48157 int result;
48158 void *argp1 = 0 ;
48159 int res1 = 0 ;
48160 PyObject *swig_obj[1] ;
48161
48162 if (!args) SWIG_fail;
48163 swig_obj[0] = args;
48164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48165 if (!SWIG_IsOK(res1)) {
48166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48167 }
48168 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48169 {
48170 PyThreadState* __tstate = wxPyBeginAllowThreads();
48171 result = (int)((wxItemContainer const *)arg1)->GetSelection();
48172 wxPyEndAllowThreads(__tstate);
48173 if (PyErr_Occurred()) SWIG_fail;
48174 }
48175 resultobj = SWIG_From_int(static_cast< int >(result));
48176 return resultobj;
48177 fail:
48178 return NULL;
48179 }
48180
48181
48182 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48183 PyObject *resultobj = 0;
48184 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48185 wxString *arg2 = 0 ;
48186 bool result;
48187 void *argp1 = 0 ;
48188 int res1 = 0 ;
48189 bool temp2 = false ;
48190 PyObject * obj0 = 0 ;
48191 PyObject * obj1 = 0 ;
48192 char * kwnames[] = {
48193 (char *) "self",(char *) "s", NULL
48194 };
48195
48196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48198 if (!SWIG_IsOK(res1)) {
48199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48200 }
48201 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48202 {
48203 arg2 = wxString_in_helper(obj1);
48204 if (arg2 == NULL) SWIG_fail;
48205 temp2 = true;
48206 }
48207 {
48208 PyThreadState* __tstate = wxPyBeginAllowThreads();
48209 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
48210 wxPyEndAllowThreads(__tstate);
48211 if (PyErr_Occurred()) SWIG_fail;
48212 }
48213 {
48214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48215 }
48216 {
48217 if (temp2)
48218 delete arg2;
48219 }
48220 return resultobj;
48221 fail:
48222 {
48223 if (temp2)
48224 delete arg2;
48225 }
48226 return NULL;
48227 }
48228
48229
48230 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48231 PyObject *resultobj = 0;
48232 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48233 wxString result;
48234 void *argp1 = 0 ;
48235 int res1 = 0 ;
48236 PyObject *swig_obj[1] ;
48237
48238 if (!args) SWIG_fail;
48239 swig_obj[0] = args;
48240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48241 if (!SWIG_IsOK(res1)) {
48242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48243 }
48244 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48245 {
48246 PyThreadState* __tstate = wxPyBeginAllowThreads();
48247 result = ((wxItemContainer const *)arg1)->GetStringSelection();
48248 wxPyEndAllowThreads(__tstate);
48249 if (PyErr_Occurred()) SWIG_fail;
48250 }
48251 {
48252 #if wxUSE_UNICODE
48253 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48254 #else
48255 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48256 #endif
48257 }
48258 return resultobj;
48259 fail:
48260 return NULL;
48261 }
48262
48263
48264 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48265 PyObject *resultobj = 0;
48266 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48267 int arg2 ;
48268 void *argp1 = 0 ;
48269 int res1 = 0 ;
48270 int val2 ;
48271 int ecode2 = 0 ;
48272 PyObject * obj0 = 0 ;
48273 PyObject * obj1 = 0 ;
48274 char * kwnames[] = {
48275 (char *) "self",(char *) "n", NULL
48276 };
48277
48278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
48279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48280 if (!SWIG_IsOK(res1)) {
48281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48282 }
48283 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48284 ecode2 = SWIG_AsVal_int(obj1, &val2);
48285 if (!SWIG_IsOK(ecode2)) {
48286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
48287 }
48288 arg2 = static_cast< int >(val2);
48289 {
48290 PyThreadState* __tstate = wxPyBeginAllowThreads();
48291 (arg1)->Select(arg2);
48292 wxPyEndAllowThreads(__tstate);
48293 if (PyErr_Occurred()) SWIG_fail;
48294 }
48295 resultobj = SWIG_Py_Void();
48296 return resultobj;
48297 fail:
48298 return NULL;
48299 }
48300
48301
48302 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48303 PyObject *obj;
48304 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48305 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
48306 return SWIG_Py_Void();
48307 }
48308
48309 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48310 PyObject *obj;
48311 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48312 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
48313 return SWIG_Py_Void();
48314 }
48315
48316 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48317 PyObject *resultobj = 0;
48318 wxSizerItem *result = 0 ;
48319
48320 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
48321 {
48322 PyThreadState* __tstate = wxPyBeginAllowThreads();
48323 result = (wxSizerItem *)new wxSizerItem();
48324 wxPyEndAllowThreads(__tstate);
48325 if (PyErr_Occurred()) SWIG_fail;
48326 }
48327 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
48328 return resultobj;
48329 fail:
48330 return NULL;
48331 }
48332
48333
48334 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48335 PyObject *resultobj = 0;
48336 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48337 void *argp1 = 0 ;
48338 int res1 = 0 ;
48339 PyObject *swig_obj[1] ;
48340
48341 if (!args) SWIG_fail;
48342 swig_obj[0] = args;
48343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48344 if (!SWIG_IsOK(res1)) {
48345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48346 }
48347 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48348 {
48349 PyThreadState* __tstate = wxPyBeginAllowThreads();
48350 delete arg1;
48351
48352 wxPyEndAllowThreads(__tstate);
48353 if (PyErr_Occurred()) SWIG_fail;
48354 }
48355 resultobj = SWIG_Py_Void();
48356 return resultobj;
48357 fail:
48358 return NULL;
48359 }
48360
48361
48362 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48363 PyObject *resultobj = 0;
48364 wxWindow *arg1 = (wxWindow *) 0 ;
48365 int arg2 ;
48366 int arg3 ;
48367 int arg4 ;
48368 PyObject *arg5 = (PyObject *) NULL ;
48369 wxSizerItem *result = 0 ;
48370 void *argp1 = 0 ;
48371 int res1 = 0 ;
48372 int val2 ;
48373 int ecode2 = 0 ;
48374 int val3 ;
48375 int ecode3 = 0 ;
48376 int val4 ;
48377 int ecode4 = 0 ;
48378 PyObject * obj0 = 0 ;
48379 PyObject * obj1 = 0 ;
48380 PyObject * obj2 = 0 ;
48381 PyObject * obj3 = 0 ;
48382 PyObject * obj4 = 0 ;
48383 char * kwnames[] = {
48384 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48385 };
48386
48387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
48389 if (!SWIG_IsOK(res1)) {
48390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
48391 }
48392 arg1 = reinterpret_cast< wxWindow * >(argp1);
48393 ecode2 = SWIG_AsVal_int(obj1, &val2);
48394 if (!SWIG_IsOK(ecode2)) {
48395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
48396 }
48397 arg2 = static_cast< int >(val2);
48398 ecode3 = SWIG_AsVal_int(obj2, &val3);
48399 if (!SWIG_IsOK(ecode3)) {
48400 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
48401 }
48402 arg3 = static_cast< int >(val3);
48403 ecode4 = SWIG_AsVal_int(obj3, &val4);
48404 if (!SWIG_IsOK(ecode4)) {
48405 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
48406 }
48407 arg4 = static_cast< int >(val4);
48408 if (obj4) {
48409 arg5 = obj4;
48410 }
48411 {
48412 PyThreadState* __tstate = wxPyBeginAllowThreads();
48413 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48414 wxPyEndAllowThreads(__tstate);
48415 if (PyErr_Occurred()) SWIG_fail;
48416 }
48417 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48418 return resultobj;
48419 fail:
48420 return NULL;
48421 }
48422
48423
48424 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48425 PyObject *resultobj = 0;
48426 int arg1 ;
48427 int arg2 ;
48428 int arg3 ;
48429 int arg4 ;
48430 int arg5 ;
48431 PyObject *arg6 = (PyObject *) NULL ;
48432 wxSizerItem *result = 0 ;
48433 int val1 ;
48434 int ecode1 = 0 ;
48435 int val2 ;
48436 int ecode2 = 0 ;
48437 int val3 ;
48438 int ecode3 = 0 ;
48439 int val4 ;
48440 int ecode4 = 0 ;
48441 int val5 ;
48442 int ecode5 = 0 ;
48443 PyObject * obj0 = 0 ;
48444 PyObject * obj1 = 0 ;
48445 PyObject * obj2 = 0 ;
48446 PyObject * obj3 = 0 ;
48447 PyObject * obj4 = 0 ;
48448 PyObject * obj5 = 0 ;
48449 char * kwnames[] = {
48450 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48451 };
48452
48453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
48454 ecode1 = SWIG_AsVal_int(obj0, &val1);
48455 if (!SWIG_IsOK(ecode1)) {
48456 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
48457 }
48458 arg1 = static_cast< int >(val1);
48459 ecode2 = SWIG_AsVal_int(obj1, &val2);
48460 if (!SWIG_IsOK(ecode2)) {
48461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
48462 }
48463 arg2 = static_cast< int >(val2);
48464 ecode3 = SWIG_AsVal_int(obj2, &val3);
48465 if (!SWIG_IsOK(ecode3)) {
48466 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
48467 }
48468 arg3 = static_cast< int >(val3);
48469 ecode4 = SWIG_AsVal_int(obj3, &val4);
48470 if (!SWIG_IsOK(ecode4)) {
48471 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
48472 }
48473 arg4 = static_cast< int >(val4);
48474 ecode5 = SWIG_AsVal_int(obj4, &val5);
48475 if (!SWIG_IsOK(ecode5)) {
48476 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
48477 }
48478 arg5 = static_cast< int >(val5);
48479 if (obj5) {
48480 arg6 = obj5;
48481 }
48482 {
48483 PyThreadState* __tstate = wxPyBeginAllowThreads();
48484 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
48485 wxPyEndAllowThreads(__tstate);
48486 if (PyErr_Occurred()) SWIG_fail;
48487 }
48488 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48489 return resultobj;
48490 fail:
48491 return NULL;
48492 }
48493
48494
48495 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48496 PyObject *resultobj = 0;
48497 wxSizer *arg1 = (wxSizer *) 0 ;
48498 int arg2 ;
48499 int arg3 ;
48500 int arg4 ;
48501 PyObject *arg5 = (PyObject *) NULL ;
48502 wxSizerItem *result = 0 ;
48503 int res1 = 0 ;
48504 int val2 ;
48505 int ecode2 = 0 ;
48506 int val3 ;
48507 int ecode3 = 0 ;
48508 int val4 ;
48509 int ecode4 = 0 ;
48510 PyObject * obj0 = 0 ;
48511 PyObject * obj1 = 0 ;
48512 PyObject * obj2 = 0 ;
48513 PyObject * obj3 = 0 ;
48514 PyObject * obj4 = 0 ;
48515 char * kwnames[] = {
48516 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48517 };
48518
48519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48520 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
48521 if (!SWIG_IsOK(res1)) {
48522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
48523 }
48524 ecode2 = SWIG_AsVal_int(obj1, &val2);
48525 if (!SWIG_IsOK(ecode2)) {
48526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
48527 }
48528 arg2 = static_cast< int >(val2);
48529 ecode3 = SWIG_AsVal_int(obj2, &val3);
48530 if (!SWIG_IsOK(ecode3)) {
48531 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
48532 }
48533 arg3 = static_cast< int >(val3);
48534 ecode4 = SWIG_AsVal_int(obj3, &val4);
48535 if (!SWIG_IsOK(ecode4)) {
48536 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
48537 }
48538 arg4 = static_cast< int >(val4);
48539 if (obj4) {
48540 arg5 = obj4;
48541 }
48542 {
48543 PyThreadState* __tstate = wxPyBeginAllowThreads();
48544 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48545 wxPyEndAllowThreads(__tstate);
48546 if (PyErr_Occurred()) SWIG_fail;
48547 }
48548 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48549 return resultobj;
48550 fail:
48551 return NULL;
48552 }
48553
48554
48555 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48556 PyObject *resultobj = 0;
48557 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48558 void *argp1 = 0 ;
48559 int res1 = 0 ;
48560 PyObject *swig_obj[1] ;
48561
48562 if (!args) SWIG_fail;
48563 swig_obj[0] = args;
48564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48565 if (!SWIG_IsOK(res1)) {
48566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48567 }
48568 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48569 {
48570 PyThreadState* __tstate = wxPyBeginAllowThreads();
48571 (arg1)->DeleteWindows();
48572 wxPyEndAllowThreads(__tstate);
48573 if (PyErr_Occurred()) SWIG_fail;
48574 }
48575 resultobj = SWIG_Py_Void();
48576 return resultobj;
48577 fail:
48578 return NULL;
48579 }
48580
48581
48582 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48583 PyObject *resultobj = 0;
48584 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48585 void *argp1 = 0 ;
48586 int res1 = 0 ;
48587 PyObject *swig_obj[1] ;
48588
48589 if (!args) SWIG_fail;
48590 swig_obj[0] = args;
48591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48592 if (!SWIG_IsOK(res1)) {
48593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48594 }
48595 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48596 {
48597 PyThreadState* __tstate = wxPyBeginAllowThreads();
48598 (arg1)->DetachSizer();
48599 wxPyEndAllowThreads(__tstate);
48600 if (PyErr_Occurred()) SWIG_fail;
48601 }
48602 resultobj = SWIG_Py_Void();
48603 return resultobj;
48604 fail:
48605 return NULL;
48606 }
48607
48608
48609 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48610 PyObject *resultobj = 0;
48611 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48612 wxSize result;
48613 void *argp1 = 0 ;
48614 int res1 = 0 ;
48615 PyObject *swig_obj[1] ;
48616
48617 if (!args) SWIG_fail;
48618 swig_obj[0] = args;
48619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48620 if (!SWIG_IsOK(res1)) {
48621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48622 }
48623 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48624 {
48625 PyThreadState* __tstate = wxPyBeginAllowThreads();
48626 result = (arg1)->GetSize();
48627 wxPyEndAllowThreads(__tstate);
48628 if (PyErr_Occurred()) SWIG_fail;
48629 }
48630 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48631 return resultobj;
48632 fail:
48633 return NULL;
48634 }
48635
48636
48637 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48638 PyObject *resultobj = 0;
48639 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48640 wxSize result;
48641 void *argp1 = 0 ;
48642 int res1 = 0 ;
48643 PyObject *swig_obj[1] ;
48644
48645 if (!args) SWIG_fail;
48646 swig_obj[0] = args;
48647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48648 if (!SWIG_IsOK(res1)) {
48649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48650 }
48651 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48652 {
48653 PyThreadState* __tstate = wxPyBeginAllowThreads();
48654 result = (arg1)->CalcMin();
48655 wxPyEndAllowThreads(__tstate);
48656 if (PyErr_Occurred()) SWIG_fail;
48657 }
48658 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48659 return resultobj;
48660 fail:
48661 return NULL;
48662 }
48663
48664
48665 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48666 PyObject *resultobj = 0;
48667 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48668 wxPoint *arg2 = 0 ;
48669 wxSize *arg3 = 0 ;
48670 void *argp1 = 0 ;
48671 int res1 = 0 ;
48672 wxPoint temp2 ;
48673 wxSize temp3 ;
48674 PyObject * obj0 = 0 ;
48675 PyObject * obj1 = 0 ;
48676 PyObject * obj2 = 0 ;
48677 char * kwnames[] = {
48678 (char *) "self",(char *) "pos",(char *) "size", NULL
48679 };
48680
48681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48683 if (!SWIG_IsOK(res1)) {
48684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48685 }
48686 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48687 {
48688 arg2 = &temp2;
48689 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
48690 }
48691 {
48692 arg3 = &temp3;
48693 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
48694 }
48695 {
48696 PyThreadState* __tstate = wxPyBeginAllowThreads();
48697 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
48698 wxPyEndAllowThreads(__tstate);
48699 if (PyErr_Occurred()) SWIG_fail;
48700 }
48701 resultobj = SWIG_Py_Void();
48702 return resultobj;
48703 fail:
48704 return NULL;
48705 }
48706
48707
48708 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48709 PyObject *resultobj = 0;
48710 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48711 wxSize result;
48712 void *argp1 = 0 ;
48713 int res1 = 0 ;
48714 PyObject *swig_obj[1] ;
48715
48716 if (!args) SWIG_fail;
48717 swig_obj[0] = args;
48718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48719 if (!SWIG_IsOK(res1)) {
48720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48721 }
48722 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48723 {
48724 PyThreadState* __tstate = wxPyBeginAllowThreads();
48725 result = (arg1)->GetMinSize();
48726 wxPyEndAllowThreads(__tstate);
48727 if (PyErr_Occurred()) SWIG_fail;
48728 }
48729 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48730 return resultobj;
48731 fail:
48732 return NULL;
48733 }
48734
48735
48736 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48737 PyObject *resultobj = 0;
48738 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48739 wxSize result;
48740 void *argp1 = 0 ;
48741 int res1 = 0 ;
48742 PyObject *swig_obj[1] ;
48743
48744 if (!args) SWIG_fail;
48745 swig_obj[0] = args;
48746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48747 if (!SWIG_IsOK(res1)) {
48748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
48749 }
48750 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48751 {
48752 PyThreadState* __tstate = wxPyBeginAllowThreads();
48753 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
48754 wxPyEndAllowThreads(__tstate);
48755 if (PyErr_Occurred()) SWIG_fail;
48756 }
48757 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48758 return resultobj;
48759 fail:
48760 return NULL;
48761 }
48762
48763
48764 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48765 PyObject *resultobj = 0;
48766 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48767 int arg2 ;
48768 int arg3 ;
48769 void *argp1 = 0 ;
48770 int res1 = 0 ;
48771 int val2 ;
48772 int ecode2 = 0 ;
48773 int val3 ;
48774 int ecode3 = 0 ;
48775 PyObject * obj0 = 0 ;
48776 PyObject * obj1 = 0 ;
48777 PyObject * obj2 = 0 ;
48778 char * kwnames[] = {
48779 (char *) "self",(char *) "x",(char *) "y", NULL
48780 };
48781
48782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48784 if (!SWIG_IsOK(res1)) {
48785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48786 }
48787 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48788 ecode2 = SWIG_AsVal_int(obj1, &val2);
48789 if (!SWIG_IsOK(ecode2)) {
48790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
48791 }
48792 arg2 = static_cast< int >(val2);
48793 ecode3 = SWIG_AsVal_int(obj2, &val3);
48794 if (!SWIG_IsOK(ecode3)) {
48795 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
48796 }
48797 arg3 = static_cast< int >(val3);
48798 {
48799 PyThreadState* __tstate = wxPyBeginAllowThreads();
48800 (arg1)->SetInitSize(arg2,arg3);
48801 wxPyEndAllowThreads(__tstate);
48802 if (PyErr_Occurred()) SWIG_fail;
48803 }
48804 resultobj = SWIG_Py_Void();
48805 return resultobj;
48806 fail:
48807 return NULL;
48808 }
48809
48810
48811 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48812 PyObject *resultobj = 0;
48813 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48814 int arg2 ;
48815 int arg3 ;
48816 void *argp1 = 0 ;
48817 int res1 = 0 ;
48818 int val2 ;
48819 int ecode2 = 0 ;
48820 int val3 ;
48821 int ecode3 = 0 ;
48822 PyObject * obj0 = 0 ;
48823 PyObject * obj1 = 0 ;
48824 PyObject * obj2 = 0 ;
48825 char * kwnames[] = {
48826 (char *) "self",(char *) "width",(char *) "height", NULL
48827 };
48828
48829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48831 if (!SWIG_IsOK(res1)) {
48832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48833 }
48834 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48835 ecode2 = SWIG_AsVal_int(obj1, &val2);
48836 if (!SWIG_IsOK(ecode2)) {
48837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
48838 }
48839 arg2 = static_cast< int >(val2);
48840 ecode3 = SWIG_AsVal_int(obj2, &val3);
48841 if (!SWIG_IsOK(ecode3)) {
48842 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
48843 }
48844 arg3 = static_cast< int >(val3);
48845 {
48846 PyThreadState* __tstate = wxPyBeginAllowThreads();
48847 (arg1)->SetRatio(arg2,arg3);
48848 wxPyEndAllowThreads(__tstate);
48849 if (PyErr_Occurred()) SWIG_fail;
48850 }
48851 resultobj = SWIG_Py_Void();
48852 return resultobj;
48853 fail:
48854 return NULL;
48855 }
48856
48857
48858 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48859 PyObject *resultobj = 0;
48860 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48861 wxSize *arg2 = 0 ;
48862 void *argp1 = 0 ;
48863 int res1 = 0 ;
48864 wxSize temp2 ;
48865 PyObject * obj0 = 0 ;
48866 PyObject * obj1 = 0 ;
48867 char * kwnames[] = {
48868 (char *) "self",(char *) "size", NULL
48869 };
48870
48871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
48872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48873 if (!SWIG_IsOK(res1)) {
48874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48875 }
48876 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48877 {
48878 arg2 = &temp2;
48879 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
48880 }
48881 {
48882 PyThreadState* __tstate = wxPyBeginAllowThreads();
48883 (arg1)->SetRatio((wxSize const &)*arg2);
48884 wxPyEndAllowThreads(__tstate);
48885 if (PyErr_Occurred()) SWIG_fail;
48886 }
48887 resultobj = SWIG_Py_Void();
48888 return resultobj;
48889 fail:
48890 return NULL;
48891 }
48892
48893
48894 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48895 PyObject *resultobj = 0;
48896 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48897 float arg2 ;
48898 void *argp1 = 0 ;
48899 int res1 = 0 ;
48900 float val2 ;
48901 int ecode2 = 0 ;
48902 PyObject * obj0 = 0 ;
48903 PyObject * obj1 = 0 ;
48904 char * kwnames[] = {
48905 (char *) "self",(char *) "ratio", NULL
48906 };
48907
48908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
48909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48910 if (!SWIG_IsOK(res1)) {
48911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48912 }
48913 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48914 ecode2 = SWIG_AsVal_float(obj1, &val2);
48915 if (!SWIG_IsOK(ecode2)) {
48916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
48917 }
48918 arg2 = static_cast< float >(val2);
48919 {
48920 PyThreadState* __tstate = wxPyBeginAllowThreads();
48921 (arg1)->SetRatio(arg2);
48922 wxPyEndAllowThreads(__tstate);
48923 if (PyErr_Occurred()) SWIG_fail;
48924 }
48925 resultobj = SWIG_Py_Void();
48926 return resultobj;
48927 fail:
48928 return NULL;
48929 }
48930
48931
48932 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48933 PyObject *resultobj = 0;
48934 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48935 float result;
48936 void *argp1 = 0 ;
48937 int res1 = 0 ;
48938 PyObject *swig_obj[1] ;
48939
48940 if (!args) SWIG_fail;
48941 swig_obj[0] = args;
48942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48943 if (!SWIG_IsOK(res1)) {
48944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48945 }
48946 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48947 {
48948 PyThreadState* __tstate = wxPyBeginAllowThreads();
48949 result = (float)(arg1)->GetRatio();
48950 wxPyEndAllowThreads(__tstate);
48951 if (PyErr_Occurred()) SWIG_fail;
48952 }
48953 resultobj = SWIG_From_float(static_cast< float >(result));
48954 return resultobj;
48955 fail:
48956 return NULL;
48957 }
48958
48959
48960 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48961 PyObject *resultobj = 0;
48962 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48963 wxRect result;
48964 void *argp1 = 0 ;
48965 int res1 = 0 ;
48966 PyObject *swig_obj[1] ;
48967
48968 if (!args) SWIG_fail;
48969 swig_obj[0] = args;
48970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48971 if (!SWIG_IsOK(res1)) {
48972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48973 }
48974 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48975 {
48976 PyThreadState* __tstate = wxPyBeginAllowThreads();
48977 result = (arg1)->GetRect();
48978 wxPyEndAllowThreads(__tstate);
48979 if (PyErr_Occurred()) SWIG_fail;
48980 }
48981 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
48982 return resultobj;
48983 fail:
48984 return NULL;
48985 }
48986
48987
48988 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48989 PyObject *resultobj = 0;
48990 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48991 bool result;
48992 void *argp1 = 0 ;
48993 int res1 = 0 ;
48994 PyObject *swig_obj[1] ;
48995
48996 if (!args) SWIG_fail;
48997 swig_obj[0] = args;
48998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48999 if (!SWIG_IsOK(res1)) {
49000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49001 }
49002 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49003 {
49004 PyThreadState* __tstate = wxPyBeginAllowThreads();
49005 result = (bool)(arg1)->IsWindow();
49006 wxPyEndAllowThreads(__tstate);
49007 if (PyErr_Occurred()) SWIG_fail;
49008 }
49009 {
49010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49011 }
49012 return resultobj;
49013 fail:
49014 return NULL;
49015 }
49016
49017
49018 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49019 PyObject *resultobj = 0;
49020 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49021 bool result;
49022 void *argp1 = 0 ;
49023 int res1 = 0 ;
49024 PyObject *swig_obj[1] ;
49025
49026 if (!args) SWIG_fail;
49027 swig_obj[0] = args;
49028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49029 if (!SWIG_IsOK(res1)) {
49030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49031 }
49032 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49033 {
49034 PyThreadState* __tstate = wxPyBeginAllowThreads();
49035 result = (bool)(arg1)->IsSizer();
49036 wxPyEndAllowThreads(__tstate);
49037 if (PyErr_Occurred()) SWIG_fail;
49038 }
49039 {
49040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49041 }
49042 return resultobj;
49043 fail:
49044 return NULL;
49045 }
49046
49047
49048 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49049 PyObject *resultobj = 0;
49050 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49051 bool result;
49052 void *argp1 = 0 ;
49053 int res1 = 0 ;
49054 PyObject *swig_obj[1] ;
49055
49056 if (!args) SWIG_fail;
49057 swig_obj[0] = args;
49058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49059 if (!SWIG_IsOK(res1)) {
49060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49061 }
49062 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49063 {
49064 PyThreadState* __tstate = wxPyBeginAllowThreads();
49065 result = (bool)(arg1)->IsSpacer();
49066 wxPyEndAllowThreads(__tstate);
49067 if (PyErr_Occurred()) SWIG_fail;
49068 }
49069 {
49070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49071 }
49072 return resultobj;
49073 fail:
49074 return NULL;
49075 }
49076
49077
49078 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49079 PyObject *resultobj = 0;
49080 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49081 int arg2 ;
49082 void *argp1 = 0 ;
49083 int res1 = 0 ;
49084 int val2 ;
49085 int ecode2 = 0 ;
49086 PyObject * obj0 = 0 ;
49087 PyObject * obj1 = 0 ;
49088 char * kwnames[] = {
49089 (char *) "self",(char *) "proportion", NULL
49090 };
49091
49092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
49093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49094 if (!SWIG_IsOK(res1)) {
49095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49096 }
49097 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49098 ecode2 = SWIG_AsVal_int(obj1, &val2);
49099 if (!SWIG_IsOK(ecode2)) {
49100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
49101 }
49102 arg2 = static_cast< int >(val2);
49103 {
49104 PyThreadState* __tstate = wxPyBeginAllowThreads();
49105 (arg1)->SetProportion(arg2);
49106 wxPyEndAllowThreads(__tstate);
49107 if (PyErr_Occurred()) SWIG_fail;
49108 }
49109 resultobj = SWIG_Py_Void();
49110 return resultobj;
49111 fail:
49112 return NULL;
49113 }
49114
49115
49116 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49117 PyObject *resultobj = 0;
49118 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49119 int result;
49120 void *argp1 = 0 ;
49121 int res1 = 0 ;
49122 PyObject *swig_obj[1] ;
49123
49124 if (!args) SWIG_fail;
49125 swig_obj[0] = args;
49126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49127 if (!SWIG_IsOK(res1)) {
49128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49129 }
49130 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49131 {
49132 PyThreadState* __tstate = wxPyBeginAllowThreads();
49133 result = (int)(arg1)->GetProportion();
49134 wxPyEndAllowThreads(__tstate);
49135 if (PyErr_Occurred()) SWIG_fail;
49136 }
49137 resultobj = SWIG_From_int(static_cast< int >(result));
49138 return resultobj;
49139 fail:
49140 return NULL;
49141 }
49142
49143
49144 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49145 PyObject *resultobj = 0;
49146 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49147 int arg2 ;
49148 void *argp1 = 0 ;
49149 int res1 = 0 ;
49150 int val2 ;
49151 int ecode2 = 0 ;
49152 PyObject * obj0 = 0 ;
49153 PyObject * obj1 = 0 ;
49154 char * kwnames[] = {
49155 (char *) "self",(char *) "flag", NULL
49156 };
49157
49158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
49159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49160 if (!SWIG_IsOK(res1)) {
49161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49162 }
49163 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49164 ecode2 = SWIG_AsVal_int(obj1, &val2);
49165 if (!SWIG_IsOK(ecode2)) {
49166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
49167 }
49168 arg2 = static_cast< int >(val2);
49169 {
49170 PyThreadState* __tstate = wxPyBeginAllowThreads();
49171 (arg1)->SetFlag(arg2);
49172 wxPyEndAllowThreads(__tstate);
49173 if (PyErr_Occurred()) SWIG_fail;
49174 }
49175 resultobj = SWIG_Py_Void();
49176 return resultobj;
49177 fail:
49178 return NULL;
49179 }
49180
49181
49182 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49183 PyObject *resultobj = 0;
49184 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49185 int result;
49186 void *argp1 = 0 ;
49187 int res1 = 0 ;
49188 PyObject *swig_obj[1] ;
49189
49190 if (!args) SWIG_fail;
49191 swig_obj[0] = args;
49192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49193 if (!SWIG_IsOK(res1)) {
49194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49195 }
49196 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49197 {
49198 PyThreadState* __tstate = wxPyBeginAllowThreads();
49199 result = (int)(arg1)->GetFlag();
49200 wxPyEndAllowThreads(__tstate);
49201 if (PyErr_Occurred()) SWIG_fail;
49202 }
49203 resultobj = SWIG_From_int(static_cast< int >(result));
49204 return resultobj;
49205 fail:
49206 return NULL;
49207 }
49208
49209
49210 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49211 PyObject *resultobj = 0;
49212 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49213 int arg2 ;
49214 void *argp1 = 0 ;
49215 int res1 = 0 ;
49216 int val2 ;
49217 int ecode2 = 0 ;
49218 PyObject * obj0 = 0 ;
49219 PyObject * obj1 = 0 ;
49220 char * kwnames[] = {
49221 (char *) "self",(char *) "border", NULL
49222 };
49223
49224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49226 if (!SWIG_IsOK(res1)) {
49227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49228 }
49229 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49230 ecode2 = SWIG_AsVal_int(obj1, &val2);
49231 if (!SWIG_IsOK(ecode2)) {
49232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
49233 }
49234 arg2 = static_cast< int >(val2);
49235 {
49236 PyThreadState* __tstate = wxPyBeginAllowThreads();
49237 (arg1)->SetBorder(arg2);
49238 wxPyEndAllowThreads(__tstate);
49239 if (PyErr_Occurred()) SWIG_fail;
49240 }
49241 resultobj = SWIG_Py_Void();
49242 return resultobj;
49243 fail:
49244 return NULL;
49245 }
49246
49247
49248 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49249 PyObject *resultobj = 0;
49250 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49251 int result;
49252 void *argp1 = 0 ;
49253 int res1 = 0 ;
49254 PyObject *swig_obj[1] ;
49255
49256 if (!args) SWIG_fail;
49257 swig_obj[0] = args;
49258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49259 if (!SWIG_IsOK(res1)) {
49260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49261 }
49262 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49263 {
49264 PyThreadState* __tstate = wxPyBeginAllowThreads();
49265 result = (int)(arg1)->GetBorder();
49266 wxPyEndAllowThreads(__tstate);
49267 if (PyErr_Occurred()) SWIG_fail;
49268 }
49269 resultobj = SWIG_From_int(static_cast< int >(result));
49270 return resultobj;
49271 fail:
49272 return NULL;
49273 }
49274
49275
49276 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49277 PyObject *resultobj = 0;
49278 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49279 wxWindow *result = 0 ;
49280 void *argp1 = 0 ;
49281 int res1 = 0 ;
49282 PyObject *swig_obj[1] ;
49283
49284 if (!args) SWIG_fail;
49285 swig_obj[0] = args;
49286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49287 if (!SWIG_IsOK(res1)) {
49288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49289 }
49290 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49291 {
49292 PyThreadState* __tstate = wxPyBeginAllowThreads();
49293 result = (wxWindow *)(arg1)->GetWindow();
49294 wxPyEndAllowThreads(__tstate);
49295 if (PyErr_Occurred()) SWIG_fail;
49296 }
49297 {
49298 resultobj = wxPyMake_wxObject(result, 0);
49299 }
49300 return resultobj;
49301 fail:
49302 return NULL;
49303 }
49304
49305
49306 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49307 PyObject *resultobj = 0;
49308 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49309 wxWindow *arg2 = (wxWindow *) 0 ;
49310 void *argp1 = 0 ;
49311 int res1 = 0 ;
49312 void *argp2 = 0 ;
49313 int res2 = 0 ;
49314 PyObject * obj0 = 0 ;
49315 PyObject * obj1 = 0 ;
49316 char * kwnames[] = {
49317 (char *) "self",(char *) "window", NULL
49318 };
49319
49320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
49321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49322 if (!SWIG_IsOK(res1)) {
49323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49324 }
49325 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49326 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
49327 if (!SWIG_IsOK(res2)) {
49328 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
49329 }
49330 arg2 = reinterpret_cast< wxWindow * >(argp2);
49331 {
49332 PyThreadState* __tstate = wxPyBeginAllowThreads();
49333 (arg1)->SetWindow(arg2);
49334 wxPyEndAllowThreads(__tstate);
49335 if (PyErr_Occurred()) SWIG_fail;
49336 }
49337 resultobj = SWIG_Py_Void();
49338 return resultobj;
49339 fail:
49340 return NULL;
49341 }
49342
49343
49344 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49345 PyObject *resultobj = 0;
49346 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49347 wxSizer *result = 0 ;
49348 void *argp1 = 0 ;
49349 int res1 = 0 ;
49350 PyObject *swig_obj[1] ;
49351
49352 if (!args) SWIG_fail;
49353 swig_obj[0] = args;
49354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49355 if (!SWIG_IsOK(res1)) {
49356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49357 }
49358 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49359 {
49360 PyThreadState* __tstate = wxPyBeginAllowThreads();
49361 result = (wxSizer *)(arg1)->GetSizer();
49362 wxPyEndAllowThreads(__tstate);
49363 if (PyErr_Occurred()) SWIG_fail;
49364 }
49365 {
49366 resultobj = wxPyMake_wxObject(result, (bool)0);
49367 }
49368 return resultobj;
49369 fail:
49370 return NULL;
49371 }
49372
49373
49374 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49375 PyObject *resultobj = 0;
49376 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49377 wxSizer *arg2 = (wxSizer *) 0 ;
49378 void *argp1 = 0 ;
49379 int res1 = 0 ;
49380 int res2 = 0 ;
49381 PyObject * obj0 = 0 ;
49382 PyObject * obj1 = 0 ;
49383 char * kwnames[] = {
49384 (char *) "self",(char *) "sizer", NULL
49385 };
49386
49387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49389 if (!SWIG_IsOK(res1)) {
49390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49391 }
49392 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49393 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49394 if (!SWIG_IsOK(res2)) {
49395 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
49396 }
49397 {
49398 PyThreadState* __tstate = wxPyBeginAllowThreads();
49399 (arg1)->SetSizer(arg2);
49400 wxPyEndAllowThreads(__tstate);
49401 if (PyErr_Occurred()) SWIG_fail;
49402 }
49403 resultobj = SWIG_Py_Void();
49404 return resultobj;
49405 fail:
49406 return NULL;
49407 }
49408
49409
49410 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49411 PyObject *resultobj = 0;
49412 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49413 wxSize result;
49414 void *argp1 = 0 ;
49415 int res1 = 0 ;
49416 PyObject *swig_obj[1] ;
49417
49418 if (!args) SWIG_fail;
49419 swig_obj[0] = args;
49420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49421 if (!SWIG_IsOK(res1)) {
49422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49423 }
49424 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49425 {
49426 PyThreadState* __tstate = wxPyBeginAllowThreads();
49427 result = (arg1)->GetSpacer();
49428 wxPyEndAllowThreads(__tstate);
49429 if (PyErr_Occurred()) SWIG_fail;
49430 }
49431 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49432 return resultobj;
49433 fail:
49434 return NULL;
49435 }
49436
49437
49438 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49439 PyObject *resultobj = 0;
49440 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49441 wxSize *arg2 = 0 ;
49442 void *argp1 = 0 ;
49443 int res1 = 0 ;
49444 wxSize temp2 ;
49445 PyObject * obj0 = 0 ;
49446 PyObject * obj1 = 0 ;
49447 char * kwnames[] = {
49448 (char *) "self",(char *) "size", NULL
49449 };
49450
49451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
49452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49453 if (!SWIG_IsOK(res1)) {
49454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49455 }
49456 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49457 {
49458 arg2 = &temp2;
49459 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
49460 }
49461 {
49462 PyThreadState* __tstate = wxPyBeginAllowThreads();
49463 (arg1)->SetSpacer((wxSize const &)*arg2);
49464 wxPyEndAllowThreads(__tstate);
49465 if (PyErr_Occurred()) SWIG_fail;
49466 }
49467 resultobj = SWIG_Py_Void();
49468 return resultobj;
49469 fail:
49470 return NULL;
49471 }
49472
49473
49474 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49475 PyObject *resultobj = 0;
49476 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49477 bool arg2 ;
49478 void *argp1 = 0 ;
49479 int res1 = 0 ;
49480 bool val2 ;
49481 int ecode2 = 0 ;
49482 PyObject * obj0 = 0 ;
49483 PyObject * obj1 = 0 ;
49484 char * kwnames[] = {
49485 (char *) "self",(char *) "show", NULL
49486 };
49487
49488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
49489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49490 if (!SWIG_IsOK(res1)) {
49491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49492 }
49493 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49494 ecode2 = SWIG_AsVal_bool(obj1, &val2);
49495 if (!SWIG_IsOK(ecode2)) {
49496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
49497 }
49498 arg2 = static_cast< bool >(val2);
49499 {
49500 PyThreadState* __tstate = wxPyBeginAllowThreads();
49501 (arg1)->Show(arg2);
49502 wxPyEndAllowThreads(__tstate);
49503 if (PyErr_Occurred()) SWIG_fail;
49504 }
49505 resultobj = SWIG_Py_Void();
49506 return resultobj;
49507 fail:
49508 return NULL;
49509 }
49510
49511
49512 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49513 PyObject *resultobj = 0;
49514 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49515 bool result;
49516 void *argp1 = 0 ;
49517 int res1 = 0 ;
49518 PyObject *swig_obj[1] ;
49519
49520 if (!args) SWIG_fail;
49521 swig_obj[0] = args;
49522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49523 if (!SWIG_IsOK(res1)) {
49524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49525 }
49526 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49527 {
49528 PyThreadState* __tstate = wxPyBeginAllowThreads();
49529 result = (bool)(arg1)->IsShown();
49530 wxPyEndAllowThreads(__tstate);
49531 if (PyErr_Occurred()) SWIG_fail;
49532 }
49533 {
49534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49535 }
49536 return resultobj;
49537 fail:
49538 return NULL;
49539 }
49540
49541
49542 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49543 PyObject *resultobj = 0;
49544 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49545 wxPoint result;
49546 void *argp1 = 0 ;
49547 int res1 = 0 ;
49548 PyObject *swig_obj[1] ;
49549
49550 if (!args) SWIG_fail;
49551 swig_obj[0] = args;
49552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49553 if (!SWIG_IsOK(res1)) {
49554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49555 }
49556 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49557 {
49558 PyThreadState* __tstate = wxPyBeginAllowThreads();
49559 result = (arg1)->GetPosition();
49560 wxPyEndAllowThreads(__tstate);
49561 if (PyErr_Occurred()) SWIG_fail;
49562 }
49563 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
49564 return resultobj;
49565 fail:
49566 return NULL;
49567 }
49568
49569
49570 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49571 PyObject *resultobj = 0;
49572 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49573 PyObject *result = 0 ;
49574 void *argp1 = 0 ;
49575 int res1 = 0 ;
49576 PyObject *swig_obj[1] ;
49577
49578 if (!args) SWIG_fail;
49579 swig_obj[0] = args;
49580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49581 if (!SWIG_IsOK(res1)) {
49582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49583 }
49584 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49585 {
49586 PyThreadState* __tstate = wxPyBeginAllowThreads();
49587 result = (PyObject *)wxSizerItem_GetUserData(arg1);
49588 wxPyEndAllowThreads(__tstate);
49589 if (PyErr_Occurred()) SWIG_fail;
49590 }
49591 resultobj = result;
49592 return resultobj;
49593 fail:
49594 return NULL;
49595 }
49596
49597
49598 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49599 PyObject *resultobj = 0;
49600 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49601 PyObject *arg2 = (PyObject *) 0 ;
49602 void *argp1 = 0 ;
49603 int res1 = 0 ;
49604 PyObject * obj0 = 0 ;
49605 PyObject * obj1 = 0 ;
49606 char * kwnames[] = {
49607 (char *) "self",(char *) "userData", NULL
49608 };
49609
49610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
49611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49612 if (!SWIG_IsOK(res1)) {
49613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49614 }
49615 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49616 arg2 = obj1;
49617 {
49618 PyThreadState* __tstate = wxPyBeginAllowThreads();
49619 wxSizerItem_SetUserData(arg1,arg2);
49620 wxPyEndAllowThreads(__tstate);
49621 if (PyErr_Occurred()) SWIG_fail;
49622 }
49623 resultobj = SWIG_Py_Void();
49624 return resultobj;
49625 fail:
49626 return NULL;
49627 }
49628
49629
49630 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49631 PyObject *obj;
49632 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49633 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
49634 return SWIG_Py_Void();
49635 }
49636
49637 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49638 return SWIG_Python_InitShadowInstance(args);
49639 }
49640
49641 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49642 PyObject *resultobj = 0;
49643 wxSizer *arg1 = (wxSizer *) 0 ;
49644 void *argp1 = 0 ;
49645 int res1 = 0 ;
49646 PyObject *swig_obj[1] ;
49647
49648 if (!args) SWIG_fail;
49649 swig_obj[0] = args;
49650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49651 if (!SWIG_IsOK(res1)) {
49652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49653 }
49654 arg1 = reinterpret_cast< wxSizer * >(argp1);
49655 {
49656 PyThreadState* __tstate = wxPyBeginAllowThreads();
49657 delete arg1;
49658
49659 wxPyEndAllowThreads(__tstate);
49660 if (PyErr_Occurred()) SWIG_fail;
49661 }
49662 resultobj = SWIG_Py_Void();
49663 return resultobj;
49664 fail:
49665 return NULL;
49666 }
49667
49668
49669 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49670 PyObject *resultobj = 0;
49671 wxSizer *arg1 = (wxSizer *) 0 ;
49672 PyObject *arg2 = (PyObject *) 0 ;
49673 void *argp1 = 0 ;
49674 int res1 = 0 ;
49675 PyObject * obj0 = 0 ;
49676 PyObject * obj1 = 0 ;
49677 char * kwnames[] = {
49678 (char *) "self",(char *) "_self", NULL
49679 };
49680
49681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
49682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49683 if (!SWIG_IsOK(res1)) {
49684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
49685 }
49686 arg1 = reinterpret_cast< wxSizer * >(argp1);
49687 arg2 = obj1;
49688 {
49689 PyThreadState* __tstate = wxPyBeginAllowThreads();
49690 wxSizer__setOORInfo(arg1,arg2);
49691 wxPyEndAllowThreads(__tstate);
49692 if (PyErr_Occurred()) SWIG_fail;
49693 }
49694 resultobj = SWIG_Py_Void();
49695 return resultobj;
49696 fail:
49697 return NULL;
49698 }
49699
49700
49701 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49702 PyObject *resultobj = 0;
49703 wxSizer *arg1 = (wxSizer *) 0 ;
49704 PyObject *arg2 = (PyObject *) 0 ;
49705 int arg3 = (int) 0 ;
49706 int arg4 = (int) 0 ;
49707 int arg5 = (int) 0 ;
49708 PyObject *arg6 = (PyObject *) NULL ;
49709 wxSizerItem *result = 0 ;
49710 void *argp1 = 0 ;
49711 int res1 = 0 ;
49712 int val3 ;
49713 int ecode3 = 0 ;
49714 int val4 ;
49715 int ecode4 = 0 ;
49716 int val5 ;
49717 int ecode5 = 0 ;
49718 PyObject * obj0 = 0 ;
49719 PyObject * obj1 = 0 ;
49720 PyObject * obj2 = 0 ;
49721 PyObject * obj3 = 0 ;
49722 PyObject * obj4 = 0 ;
49723 PyObject * obj5 = 0 ;
49724 char * kwnames[] = {
49725 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49726 };
49727
49728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49730 if (!SWIG_IsOK(res1)) {
49731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
49732 }
49733 arg1 = reinterpret_cast< wxSizer * >(argp1);
49734 arg2 = obj1;
49735 if (obj2) {
49736 ecode3 = SWIG_AsVal_int(obj2, &val3);
49737 if (!SWIG_IsOK(ecode3)) {
49738 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
49739 }
49740 arg3 = static_cast< int >(val3);
49741 }
49742 if (obj3) {
49743 ecode4 = SWIG_AsVal_int(obj3, &val4);
49744 if (!SWIG_IsOK(ecode4)) {
49745 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
49746 }
49747 arg4 = static_cast< int >(val4);
49748 }
49749 if (obj4) {
49750 ecode5 = SWIG_AsVal_int(obj4, &val5);
49751 if (!SWIG_IsOK(ecode5)) {
49752 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
49753 }
49754 arg5 = static_cast< int >(val5);
49755 }
49756 if (obj5) {
49757 arg6 = obj5;
49758 }
49759 {
49760 PyThreadState* __tstate = wxPyBeginAllowThreads();
49761 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
49762 wxPyEndAllowThreads(__tstate);
49763 if (PyErr_Occurred()) SWIG_fail;
49764 }
49765 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49766 return resultobj;
49767 fail:
49768 return NULL;
49769 }
49770
49771
49772 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49773 PyObject *resultobj = 0;
49774 wxSizer *arg1 = (wxSizer *) 0 ;
49775 int arg2 ;
49776 PyObject *arg3 = (PyObject *) 0 ;
49777 int arg4 = (int) 0 ;
49778 int arg5 = (int) 0 ;
49779 int arg6 = (int) 0 ;
49780 PyObject *arg7 = (PyObject *) NULL ;
49781 wxSizerItem *result = 0 ;
49782 void *argp1 = 0 ;
49783 int res1 = 0 ;
49784 int val2 ;
49785 int ecode2 = 0 ;
49786 int val4 ;
49787 int ecode4 = 0 ;
49788 int val5 ;
49789 int ecode5 = 0 ;
49790 int val6 ;
49791 int ecode6 = 0 ;
49792 PyObject * obj0 = 0 ;
49793 PyObject * obj1 = 0 ;
49794 PyObject * obj2 = 0 ;
49795 PyObject * obj3 = 0 ;
49796 PyObject * obj4 = 0 ;
49797 PyObject * obj5 = 0 ;
49798 PyObject * obj6 = 0 ;
49799 char * kwnames[] = {
49800 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49801 };
49802
49803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49805 if (!SWIG_IsOK(res1)) {
49806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
49807 }
49808 arg1 = reinterpret_cast< wxSizer * >(argp1);
49809 ecode2 = SWIG_AsVal_int(obj1, &val2);
49810 if (!SWIG_IsOK(ecode2)) {
49811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
49812 }
49813 arg2 = static_cast< int >(val2);
49814 arg3 = obj2;
49815 if (obj3) {
49816 ecode4 = SWIG_AsVal_int(obj3, &val4);
49817 if (!SWIG_IsOK(ecode4)) {
49818 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
49819 }
49820 arg4 = static_cast< int >(val4);
49821 }
49822 if (obj4) {
49823 ecode5 = SWIG_AsVal_int(obj4, &val5);
49824 if (!SWIG_IsOK(ecode5)) {
49825 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
49826 }
49827 arg5 = static_cast< int >(val5);
49828 }
49829 if (obj5) {
49830 ecode6 = SWIG_AsVal_int(obj5, &val6);
49831 if (!SWIG_IsOK(ecode6)) {
49832 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
49833 }
49834 arg6 = static_cast< int >(val6);
49835 }
49836 if (obj6) {
49837 arg7 = obj6;
49838 }
49839 {
49840 PyThreadState* __tstate = wxPyBeginAllowThreads();
49841 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
49842 wxPyEndAllowThreads(__tstate);
49843 if (PyErr_Occurred()) SWIG_fail;
49844 }
49845 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49846 return resultobj;
49847 fail:
49848 return NULL;
49849 }
49850
49851
49852 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49853 PyObject *resultobj = 0;
49854 wxSizer *arg1 = (wxSizer *) 0 ;
49855 PyObject *arg2 = (PyObject *) 0 ;
49856 int arg3 = (int) 0 ;
49857 int arg4 = (int) 0 ;
49858 int arg5 = (int) 0 ;
49859 PyObject *arg6 = (PyObject *) NULL ;
49860 wxSizerItem *result = 0 ;
49861 void *argp1 = 0 ;
49862 int res1 = 0 ;
49863 int val3 ;
49864 int ecode3 = 0 ;
49865 int val4 ;
49866 int ecode4 = 0 ;
49867 int val5 ;
49868 int ecode5 = 0 ;
49869 PyObject * obj0 = 0 ;
49870 PyObject * obj1 = 0 ;
49871 PyObject * obj2 = 0 ;
49872 PyObject * obj3 = 0 ;
49873 PyObject * obj4 = 0 ;
49874 PyObject * obj5 = 0 ;
49875 char * kwnames[] = {
49876 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49877 };
49878
49879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49881 if (!SWIG_IsOK(res1)) {
49882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
49883 }
49884 arg1 = reinterpret_cast< wxSizer * >(argp1);
49885 arg2 = obj1;
49886 if (obj2) {
49887 ecode3 = SWIG_AsVal_int(obj2, &val3);
49888 if (!SWIG_IsOK(ecode3)) {
49889 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
49890 }
49891 arg3 = static_cast< int >(val3);
49892 }
49893 if (obj3) {
49894 ecode4 = SWIG_AsVal_int(obj3, &val4);
49895 if (!SWIG_IsOK(ecode4)) {
49896 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
49897 }
49898 arg4 = static_cast< int >(val4);
49899 }
49900 if (obj4) {
49901 ecode5 = SWIG_AsVal_int(obj4, &val5);
49902 if (!SWIG_IsOK(ecode5)) {
49903 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
49904 }
49905 arg5 = static_cast< int >(val5);
49906 }
49907 if (obj5) {
49908 arg6 = obj5;
49909 }
49910 {
49911 PyThreadState* __tstate = wxPyBeginAllowThreads();
49912 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
49913 wxPyEndAllowThreads(__tstate);
49914 if (PyErr_Occurred()) SWIG_fail;
49915 }
49916 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49917 return resultobj;
49918 fail:
49919 return NULL;
49920 }
49921
49922
49923 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49924 PyObject *resultobj = 0;
49925 wxSizer *arg1 = (wxSizer *) 0 ;
49926 PyObject *arg2 = (PyObject *) 0 ;
49927 bool result;
49928 void *argp1 = 0 ;
49929 int res1 = 0 ;
49930 PyObject * obj0 = 0 ;
49931 PyObject * obj1 = 0 ;
49932 char * kwnames[] = {
49933 (char *) "self",(char *) "item", NULL
49934 };
49935
49936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
49937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49938 if (!SWIG_IsOK(res1)) {
49939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
49940 }
49941 arg1 = reinterpret_cast< wxSizer * >(argp1);
49942 arg2 = obj1;
49943 {
49944 PyThreadState* __tstate = wxPyBeginAllowThreads();
49945 result = (bool)wxSizer_Remove(arg1,arg2);
49946 wxPyEndAllowThreads(__tstate);
49947 if (PyErr_Occurred()) SWIG_fail;
49948 }
49949 {
49950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49951 }
49952 return resultobj;
49953 fail:
49954 return NULL;
49955 }
49956
49957
49958 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49959 PyObject *resultobj = 0;
49960 wxSizer *arg1 = (wxSizer *) 0 ;
49961 PyObject *arg2 = (PyObject *) 0 ;
49962 bool result;
49963 void *argp1 = 0 ;
49964 int res1 = 0 ;
49965 PyObject * obj0 = 0 ;
49966 PyObject * obj1 = 0 ;
49967 char * kwnames[] = {
49968 (char *) "self",(char *) "item", NULL
49969 };
49970
49971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
49972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49973 if (!SWIG_IsOK(res1)) {
49974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
49975 }
49976 arg1 = reinterpret_cast< wxSizer * >(argp1);
49977 arg2 = obj1;
49978 {
49979 PyThreadState* __tstate = wxPyBeginAllowThreads();
49980 result = (bool)wxSizer_Detach(arg1,arg2);
49981 wxPyEndAllowThreads(__tstate);
49982 if (PyErr_Occurred()) SWIG_fail;
49983 }
49984 {
49985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49986 }
49987 return resultobj;
49988 fail:
49989 return NULL;
49990 }
49991
49992
49993 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49994 PyObject *resultobj = 0;
49995 wxSizer *arg1 = (wxSizer *) 0 ;
49996 PyObject *arg2 = (PyObject *) 0 ;
49997 wxSizerItem *result = 0 ;
49998 void *argp1 = 0 ;
49999 int res1 = 0 ;
50000 PyObject * obj0 = 0 ;
50001 PyObject * obj1 = 0 ;
50002 char * kwnames[] = {
50003 (char *) "self",(char *) "item", NULL
50004 };
50005
50006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
50007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50008 if (!SWIG_IsOK(res1)) {
50009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50010 }
50011 arg1 = reinterpret_cast< wxSizer * >(argp1);
50012 arg2 = obj1;
50013 {
50014 PyThreadState* __tstate = wxPyBeginAllowThreads();
50015 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
50016 wxPyEndAllowThreads(__tstate);
50017 if (PyErr_Occurred()) SWIG_fail;
50018 }
50019 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50020 return resultobj;
50021 fail:
50022 return NULL;
50023 }
50024
50025
50026 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50027 PyObject *resultobj = 0;
50028 wxSizer *arg1 = (wxSizer *) 0 ;
50029 PyObject *arg2 = (PyObject *) 0 ;
50030 wxSize *arg3 = 0 ;
50031 void *argp1 = 0 ;
50032 int res1 = 0 ;
50033 wxSize temp3 ;
50034 PyObject * obj0 = 0 ;
50035 PyObject * obj1 = 0 ;
50036 PyObject * obj2 = 0 ;
50037 char * kwnames[] = {
50038 (char *) "self",(char *) "item",(char *) "size", NULL
50039 };
50040
50041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50043 if (!SWIG_IsOK(res1)) {
50044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50045 }
50046 arg1 = reinterpret_cast< wxSizer * >(argp1);
50047 arg2 = obj1;
50048 {
50049 arg3 = &temp3;
50050 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
50051 }
50052 {
50053 PyThreadState* __tstate = wxPyBeginAllowThreads();
50054 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
50055 wxPyEndAllowThreads(__tstate);
50056 if (PyErr_Occurred()) SWIG_fail;
50057 }
50058 resultobj = SWIG_Py_Void();
50059 return resultobj;
50060 fail:
50061 return NULL;
50062 }
50063
50064
50065 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50066 PyObject *resultobj = 0;
50067 wxSizer *arg1 = (wxSizer *) 0 ;
50068 wxWindow *arg2 = (wxWindow *) 0 ;
50069 wxWindow *arg3 = (wxWindow *) 0 ;
50070 bool arg4 = (bool) false ;
50071 bool result;
50072 void *argp1 = 0 ;
50073 int res1 = 0 ;
50074 void *argp2 = 0 ;
50075 int res2 = 0 ;
50076 void *argp3 = 0 ;
50077 int res3 = 0 ;
50078 bool val4 ;
50079 int ecode4 = 0 ;
50080 PyObject * obj0 = 0 ;
50081 PyObject * obj1 = 0 ;
50082 PyObject * obj2 = 0 ;
50083 PyObject * obj3 = 0 ;
50084 char * kwnames[] = {
50085 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
50086 };
50087
50088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50090 if (!SWIG_IsOK(res1)) {
50091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
50092 }
50093 arg1 = reinterpret_cast< wxSizer * >(argp1);
50094 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50095 if (!SWIG_IsOK(res2)) {
50096 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
50097 }
50098 arg2 = reinterpret_cast< wxWindow * >(argp2);
50099 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
50100 if (!SWIG_IsOK(res3)) {
50101 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
50102 }
50103 arg3 = reinterpret_cast< wxWindow * >(argp3);
50104 if (obj3) {
50105 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50106 if (!SWIG_IsOK(ecode4)) {
50107 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
50108 }
50109 arg4 = static_cast< bool >(val4);
50110 }
50111 {
50112 PyThreadState* __tstate = wxPyBeginAllowThreads();
50113 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50114 wxPyEndAllowThreads(__tstate);
50115 if (PyErr_Occurred()) SWIG_fail;
50116 }
50117 {
50118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50119 }
50120 return resultobj;
50121 fail:
50122 return NULL;
50123 }
50124
50125
50126 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50127 PyObject *resultobj = 0;
50128 wxSizer *arg1 = (wxSizer *) 0 ;
50129 wxSizer *arg2 = (wxSizer *) 0 ;
50130 wxSizer *arg3 = (wxSizer *) 0 ;
50131 bool arg4 = (bool) false ;
50132 bool result;
50133 void *argp1 = 0 ;
50134 int res1 = 0 ;
50135 void *argp2 = 0 ;
50136 int res2 = 0 ;
50137 void *argp3 = 0 ;
50138 int res3 = 0 ;
50139 bool val4 ;
50140 int ecode4 = 0 ;
50141 PyObject * obj0 = 0 ;
50142 PyObject * obj1 = 0 ;
50143 PyObject * obj2 = 0 ;
50144 PyObject * obj3 = 0 ;
50145 char * kwnames[] = {
50146 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
50147 };
50148
50149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50151 if (!SWIG_IsOK(res1)) {
50152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50153 }
50154 arg1 = reinterpret_cast< wxSizer * >(argp1);
50155 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50156 if (!SWIG_IsOK(res2)) {
50157 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
50158 }
50159 arg2 = reinterpret_cast< wxSizer * >(argp2);
50160 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
50161 if (!SWIG_IsOK(res3)) {
50162 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
50163 }
50164 arg3 = reinterpret_cast< wxSizer * >(argp3);
50165 if (obj3) {
50166 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50167 if (!SWIG_IsOK(ecode4)) {
50168 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
50169 }
50170 arg4 = static_cast< bool >(val4);
50171 }
50172 {
50173 PyThreadState* __tstate = wxPyBeginAllowThreads();
50174 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50175 wxPyEndAllowThreads(__tstate);
50176 if (PyErr_Occurred()) SWIG_fail;
50177 }
50178 {
50179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50180 }
50181 return resultobj;
50182 fail:
50183 return NULL;
50184 }
50185
50186
50187 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50188 PyObject *resultobj = 0;
50189 wxSizer *arg1 = (wxSizer *) 0 ;
50190 size_t arg2 ;
50191 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50192 bool result;
50193 void *argp1 = 0 ;
50194 int res1 = 0 ;
50195 size_t val2 ;
50196 int ecode2 = 0 ;
50197 void *argp3 = 0 ;
50198 int res3 = 0 ;
50199 PyObject * obj0 = 0 ;
50200 PyObject * obj1 = 0 ;
50201 PyObject * obj2 = 0 ;
50202 char * kwnames[] = {
50203 (char *) "self",(char *) "index",(char *) "newitem", NULL
50204 };
50205
50206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50208 if (!SWIG_IsOK(res1)) {
50209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50210 }
50211 arg1 = reinterpret_cast< wxSizer * >(argp1);
50212 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50213 if (!SWIG_IsOK(ecode2)) {
50214 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
50215 }
50216 arg2 = static_cast< size_t >(val2);
50217 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50218 if (!SWIG_IsOK(res3)) {
50219 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50220 }
50221 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
50222 {
50223 PyThreadState* __tstate = wxPyBeginAllowThreads();
50224 result = (bool)(arg1)->Replace(arg2,arg3);
50225 wxPyEndAllowThreads(__tstate);
50226 if (PyErr_Occurred()) SWIG_fail;
50227 }
50228 {
50229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50230 }
50231 return resultobj;
50232 fail:
50233 return NULL;
50234 }
50235
50236
50237 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50238 PyObject *resultobj = 0;
50239 wxSizer *arg1 = (wxSizer *) 0 ;
50240 wxWindow *arg2 = (wxWindow *) 0 ;
50241 void *argp1 = 0 ;
50242 int res1 = 0 ;
50243 void *argp2 = 0 ;
50244 int res2 = 0 ;
50245 PyObject * obj0 = 0 ;
50246 PyObject * obj1 = 0 ;
50247 char * kwnames[] = {
50248 (char *) "self",(char *) "window", NULL
50249 };
50250
50251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
50252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50253 if (!SWIG_IsOK(res1)) {
50254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
50255 }
50256 arg1 = reinterpret_cast< wxSizer * >(argp1);
50257 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50258 if (!SWIG_IsOK(res2)) {
50259 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
50260 }
50261 arg2 = reinterpret_cast< wxWindow * >(argp2);
50262 {
50263 PyThreadState* __tstate = wxPyBeginAllowThreads();
50264 (arg1)->SetContainingWindow(arg2);
50265 wxPyEndAllowThreads(__tstate);
50266 if (PyErr_Occurred()) SWIG_fail;
50267 }
50268 resultobj = SWIG_Py_Void();
50269 return resultobj;
50270 fail:
50271 return NULL;
50272 }
50273
50274
50275 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50276 PyObject *resultobj = 0;
50277 wxSizer *arg1 = (wxSizer *) 0 ;
50278 wxWindow *result = 0 ;
50279 void *argp1 = 0 ;
50280 int res1 = 0 ;
50281 PyObject *swig_obj[1] ;
50282
50283 if (!args) SWIG_fail;
50284 swig_obj[0] = args;
50285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50286 if (!SWIG_IsOK(res1)) {
50287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
50288 }
50289 arg1 = reinterpret_cast< wxSizer * >(argp1);
50290 {
50291 PyThreadState* __tstate = wxPyBeginAllowThreads();
50292 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
50293 wxPyEndAllowThreads(__tstate);
50294 if (PyErr_Occurred()) SWIG_fail;
50295 }
50296 {
50297 resultobj = wxPyMake_wxObject(result, 0);
50298 }
50299 return resultobj;
50300 fail:
50301 return NULL;
50302 }
50303
50304
50305 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50306 PyObject *resultobj = 0;
50307 wxSizer *arg1 = (wxSizer *) 0 ;
50308 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50309 wxSizerItem *result = 0 ;
50310 void *argp1 = 0 ;
50311 int res1 = 0 ;
50312 int res2 = 0 ;
50313 PyObject * obj0 = 0 ;
50314 PyObject * obj1 = 0 ;
50315 char * kwnames[] = {
50316 (char *) "self",(char *) "item", NULL
50317 };
50318
50319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50321 if (!SWIG_IsOK(res1)) {
50322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50323 }
50324 arg1 = reinterpret_cast< wxSizer * >(argp1);
50325 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50326 if (!SWIG_IsOK(res2)) {
50327 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50328 }
50329 {
50330 PyThreadState* __tstate = wxPyBeginAllowThreads();
50331 result = (wxSizerItem *)(arg1)->Add(arg2);
50332 wxPyEndAllowThreads(__tstate);
50333 if (PyErr_Occurred()) SWIG_fail;
50334 }
50335 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50336 return resultobj;
50337 fail:
50338 return NULL;
50339 }
50340
50341
50342 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50343 PyObject *resultobj = 0;
50344 wxSizer *arg1 = (wxSizer *) 0 ;
50345 size_t arg2 ;
50346 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50347 wxSizerItem *result = 0 ;
50348 void *argp1 = 0 ;
50349 int res1 = 0 ;
50350 size_t val2 ;
50351 int ecode2 = 0 ;
50352 int res3 = 0 ;
50353 PyObject * obj0 = 0 ;
50354 PyObject * obj1 = 0 ;
50355 PyObject * obj2 = 0 ;
50356 char * kwnames[] = {
50357 (char *) "self",(char *) "index",(char *) "item", NULL
50358 };
50359
50360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50362 if (!SWIG_IsOK(res1)) {
50363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50364 }
50365 arg1 = reinterpret_cast< wxSizer * >(argp1);
50366 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50367 if (!SWIG_IsOK(ecode2)) {
50368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
50369 }
50370 arg2 = static_cast< size_t >(val2);
50371 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50372 if (!SWIG_IsOK(res3)) {
50373 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50374 }
50375 {
50376 PyThreadState* __tstate = wxPyBeginAllowThreads();
50377 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
50378 wxPyEndAllowThreads(__tstate);
50379 if (PyErr_Occurred()) SWIG_fail;
50380 }
50381 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50382 return resultobj;
50383 fail:
50384 return NULL;
50385 }
50386
50387
50388 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50389 PyObject *resultobj = 0;
50390 wxSizer *arg1 = (wxSizer *) 0 ;
50391 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50392 wxSizerItem *result = 0 ;
50393 void *argp1 = 0 ;
50394 int res1 = 0 ;
50395 int res2 = 0 ;
50396 PyObject * obj0 = 0 ;
50397 PyObject * obj1 = 0 ;
50398 char * kwnames[] = {
50399 (char *) "self",(char *) "item", NULL
50400 };
50401
50402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
50403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50404 if (!SWIG_IsOK(res1)) {
50405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50406 }
50407 arg1 = reinterpret_cast< wxSizer * >(argp1);
50408 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50409 if (!SWIG_IsOK(res2)) {
50410 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50411 }
50412 {
50413 PyThreadState* __tstate = wxPyBeginAllowThreads();
50414 result = (wxSizerItem *)(arg1)->Prepend(arg2);
50415 wxPyEndAllowThreads(__tstate);
50416 if (PyErr_Occurred()) SWIG_fail;
50417 }
50418 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50419 return resultobj;
50420 fail:
50421 return NULL;
50422 }
50423
50424
50425 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50426 PyObject *resultobj = 0;
50427 wxSizer *arg1 = (wxSizer *) 0 ;
50428 int arg2 ;
50429 int arg3 ;
50430 int arg4 ;
50431 int arg5 ;
50432 void *argp1 = 0 ;
50433 int res1 = 0 ;
50434 int val2 ;
50435 int ecode2 = 0 ;
50436 int val3 ;
50437 int ecode3 = 0 ;
50438 int val4 ;
50439 int ecode4 = 0 ;
50440 int val5 ;
50441 int ecode5 = 0 ;
50442 PyObject * obj0 = 0 ;
50443 PyObject * obj1 = 0 ;
50444 PyObject * obj2 = 0 ;
50445 PyObject * obj3 = 0 ;
50446 PyObject * obj4 = 0 ;
50447 char * kwnames[] = {
50448 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
50449 };
50450
50451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
50452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50453 if (!SWIG_IsOK(res1)) {
50454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
50455 }
50456 arg1 = reinterpret_cast< wxSizer * >(argp1);
50457 ecode2 = SWIG_AsVal_int(obj1, &val2);
50458 if (!SWIG_IsOK(ecode2)) {
50459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
50460 }
50461 arg2 = static_cast< int >(val2);
50462 ecode3 = SWIG_AsVal_int(obj2, &val3);
50463 if (!SWIG_IsOK(ecode3)) {
50464 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
50465 }
50466 arg3 = static_cast< int >(val3);
50467 ecode4 = SWIG_AsVal_int(obj3, &val4);
50468 if (!SWIG_IsOK(ecode4)) {
50469 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
50470 }
50471 arg4 = static_cast< int >(val4);
50472 ecode5 = SWIG_AsVal_int(obj4, &val5);
50473 if (!SWIG_IsOK(ecode5)) {
50474 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
50475 }
50476 arg5 = static_cast< int >(val5);
50477 {
50478 PyThreadState* __tstate = wxPyBeginAllowThreads();
50479 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
50480 wxPyEndAllowThreads(__tstate);
50481 if (PyErr_Occurred()) SWIG_fail;
50482 }
50483 resultobj = SWIG_Py_Void();
50484 return resultobj;
50485 fail:
50486 return NULL;
50487 }
50488
50489
50490 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50491 PyObject *resultobj = 0;
50492 wxSizer *arg1 = (wxSizer *) 0 ;
50493 wxSize *arg2 = 0 ;
50494 void *argp1 = 0 ;
50495 int res1 = 0 ;
50496 wxSize temp2 ;
50497 PyObject * obj0 = 0 ;
50498 PyObject * obj1 = 0 ;
50499 char * kwnames[] = {
50500 (char *) "self",(char *) "size", NULL
50501 };
50502
50503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
50504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50505 if (!SWIG_IsOK(res1)) {
50506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50507 }
50508 arg1 = reinterpret_cast< wxSizer * >(argp1);
50509 {
50510 arg2 = &temp2;
50511 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50512 }
50513 {
50514 PyThreadState* __tstate = wxPyBeginAllowThreads();
50515 (arg1)->SetMinSize((wxSize const &)*arg2);
50516 wxPyEndAllowThreads(__tstate);
50517 if (PyErr_Occurred()) SWIG_fail;
50518 }
50519 resultobj = SWIG_Py_Void();
50520 return resultobj;
50521 fail:
50522 return NULL;
50523 }
50524
50525
50526 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50527 PyObject *resultobj = 0;
50528 wxSizer *arg1 = (wxSizer *) 0 ;
50529 wxSize result;
50530 void *argp1 = 0 ;
50531 int res1 = 0 ;
50532 PyObject *swig_obj[1] ;
50533
50534 if (!args) SWIG_fail;
50535 swig_obj[0] = args;
50536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50537 if (!SWIG_IsOK(res1)) {
50538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50539 }
50540 arg1 = reinterpret_cast< wxSizer * >(argp1);
50541 {
50542 PyThreadState* __tstate = wxPyBeginAllowThreads();
50543 result = (arg1)->GetSize();
50544 wxPyEndAllowThreads(__tstate);
50545 if (PyErr_Occurred()) SWIG_fail;
50546 }
50547 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50548 return resultobj;
50549 fail:
50550 return NULL;
50551 }
50552
50553
50554 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50555 PyObject *resultobj = 0;
50556 wxSizer *arg1 = (wxSizer *) 0 ;
50557 wxPoint result;
50558 void *argp1 = 0 ;
50559 int res1 = 0 ;
50560 PyObject *swig_obj[1] ;
50561
50562 if (!args) SWIG_fail;
50563 swig_obj[0] = args;
50564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50565 if (!SWIG_IsOK(res1)) {
50566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
50567 }
50568 arg1 = reinterpret_cast< wxSizer * >(argp1);
50569 {
50570 PyThreadState* __tstate = wxPyBeginAllowThreads();
50571 result = (arg1)->GetPosition();
50572 wxPyEndAllowThreads(__tstate);
50573 if (PyErr_Occurred()) SWIG_fail;
50574 }
50575 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
50576 return resultobj;
50577 fail:
50578 return NULL;
50579 }
50580
50581
50582 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50583 PyObject *resultobj = 0;
50584 wxSizer *arg1 = (wxSizer *) 0 ;
50585 wxSize result;
50586 void *argp1 = 0 ;
50587 int res1 = 0 ;
50588 PyObject *swig_obj[1] ;
50589
50590 if (!args) SWIG_fail;
50591 swig_obj[0] = args;
50592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50593 if (!SWIG_IsOK(res1)) {
50594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50595 }
50596 arg1 = reinterpret_cast< wxSizer * >(argp1);
50597 {
50598 PyThreadState* __tstate = wxPyBeginAllowThreads();
50599 result = (arg1)->GetMinSize();
50600 wxPyEndAllowThreads(__tstate);
50601 if (PyErr_Occurred()) SWIG_fail;
50602 }
50603 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50604 return resultobj;
50605 fail:
50606 return NULL;
50607 }
50608
50609
50610 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50611 PyObject *resultobj = 0;
50612 wxSizer *arg1 = (wxSizer *) 0 ;
50613 void *argp1 = 0 ;
50614 int res1 = 0 ;
50615 PyObject *swig_obj[1] ;
50616
50617 if (!args) SWIG_fail;
50618 swig_obj[0] = args;
50619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50620 if (!SWIG_IsOK(res1)) {
50621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
50622 }
50623 arg1 = reinterpret_cast< wxSizer * >(argp1);
50624 {
50625 PyThreadState* __tstate = wxPyBeginAllowThreads();
50626 (arg1)->RecalcSizes();
50627 wxPyEndAllowThreads(__tstate);
50628 if (PyErr_Occurred()) SWIG_fail;
50629 }
50630 resultobj = SWIG_Py_Void();
50631 return resultobj;
50632 fail:
50633 return NULL;
50634 }
50635
50636
50637 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50638 PyObject *resultobj = 0;
50639 wxSizer *arg1 = (wxSizer *) 0 ;
50640 wxSize result;
50641 void *argp1 = 0 ;
50642 int res1 = 0 ;
50643 PyObject *swig_obj[1] ;
50644
50645 if (!args) SWIG_fail;
50646 swig_obj[0] = args;
50647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50648 if (!SWIG_IsOK(res1)) {
50649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
50650 }
50651 arg1 = reinterpret_cast< wxSizer * >(argp1);
50652 {
50653 PyThreadState* __tstate = wxPyBeginAllowThreads();
50654 result = (arg1)->CalcMin();
50655 wxPyEndAllowThreads(__tstate);
50656 if (PyErr_Occurred()) SWIG_fail;
50657 }
50658 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50659 return resultobj;
50660 fail:
50661 return NULL;
50662 }
50663
50664
50665 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50666 PyObject *resultobj = 0;
50667 wxSizer *arg1 = (wxSizer *) 0 ;
50668 void *argp1 = 0 ;
50669 int res1 = 0 ;
50670 PyObject *swig_obj[1] ;
50671
50672 if (!args) SWIG_fail;
50673 swig_obj[0] = args;
50674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50675 if (!SWIG_IsOK(res1)) {
50676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
50677 }
50678 arg1 = reinterpret_cast< wxSizer * >(argp1);
50679 {
50680 PyThreadState* __tstate = wxPyBeginAllowThreads();
50681 (arg1)->Layout();
50682 wxPyEndAllowThreads(__tstate);
50683 if (PyErr_Occurred()) SWIG_fail;
50684 }
50685 resultobj = SWIG_Py_Void();
50686 return resultobj;
50687 fail:
50688 return NULL;
50689 }
50690
50691
50692 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50693 PyObject *resultobj = 0;
50694 wxSizer *arg1 = (wxSizer *) 0 ;
50695 wxWindow *arg2 = (wxWindow *) 0 ;
50696 wxSize result;
50697 void *argp1 = 0 ;
50698 int res1 = 0 ;
50699 void *argp2 = 0 ;
50700 int res2 = 0 ;
50701 PyObject * obj0 = 0 ;
50702 PyObject * obj1 = 0 ;
50703 char * kwnames[] = {
50704 (char *) "self",(char *) "window", NULL
50705 };
50706
50707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
50708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50709 if (!SWIG_IsOK(res1)) {
50710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
50711 }
50712 arg1 = reinterpret_cast< wxSizer * >(argp1);
50713 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50714 if (!SWIG_IsOK(res2)) {
50715 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
50716 }
50717 arg2 = reinterpret_cast< wxWindow * >(argp2);
50718 {
50719 PyThreadState* __tstate = wxPyBeginAllowThreads();
50720 result = (arg1)->Fit(arg2);
50721 wxPyEndAllowThreads(__tstate);
50722 if (PyErr_Occurred()) SWIG_fail;
50723 }
50724 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50725 return resultobj;
50726 fail:
50727 return NULL;
50728 }
50729
50730
50731 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50732 PyObject *resultobj = 0;
50733 wxSizer *arg1 = (wxSizer *) 0 ;
50734 wxWindow *arg2 = (wxWindow *) 0 ;
50735 void *argp1 = 0 ;
50736 int res1 = 0 ;
50737 void *argp2 = 0 ;
50738 int res2 = 0 ;
50739 PyObject * obj0 = 0 ;
50740 PyObject * obj1 = 0 ;
50741 char * kwnames[] = {
50742 (char *) "self",(char *) "window", NULL
50743 };
50744
50745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
50746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50747 if (!SWIG_IsOK(res1)) {
50748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
50749 }
50750 arg1 = reinterpret_cast< wxSizer * >(argp1);
50751 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50752 if (!SWIG_IsOK(res2)) {
50753 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
50754 }
50755 arg2 = reinterpret_cast< wxWindow * >(argp2);
50756 {
50757 PyThreadState* __tstate = wxPyBeginAllowThreads();
50758 (arg1)->FitInside(arg2);
50759 wxPyEndAllowThreads(__tstate);
50760 if (PyErr_Occurred()) SWIG_fail;
50761 }
50762 resultobj = SWIG_Py_Void();
50763 return resultobj;
50764 fail:
50765 return NULL;
50766 }
50767
50768
50769 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50770 PyObject *resultobj = 0;
50771 wxSizer *arg1 = (wxSizer *) 0 ;
50772 wxWindow *arg2 = (wxWindow *) 0 ;
50773 void *argp1 = 0 ;
50774 int res1 = 0 ;
50775 void *argp2 = 0 ;
50776 int res2 = 0 ;
50777 PyObject * obj0 = 0 ;
50778 PyObject * obj1 = 0 ;
50779 char * kwnames[] = {
50780 (char *) "self",(char *) "window", NULL
50781 };
50782
50783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
50784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50785 if (!SWIG_IsOK(res1)) {
50786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
50787 }
50788 arg1 = reinterpret_cast< wxSizer * >(argp1);
50789 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50790 if (!SWIG_IsOK(res2)) {
50791 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
50792 }
50793 arg2 = reinterpret_cast< wxWindow * >(argp2);
50794 {
50795 PyThreadState* __tstate = wxPyBeginAllowThreads();
50796 (arg1)->SetSizeHints(arg2);
50797 wxPyEndAllowThreads(__tstate);
50798 if (PyErr_Occurred()) SWIG_fail;
50799 }
50800 resultobj = SWIG_Py_Void();
50801 return resultobj;
50802 fail:
50803 return NULL;
50804 }
50805
50806
50807 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50808 PyObject *resultobj = 0;
50809 wxSizer *arg1 = (wxSizer *) 0 ;
50810 wxWindow *arg2 = (wxWindow *) 0 ;
50811 void *argp1 = 0 ;
50812 int res1 = 0 ;
50813 void *argp2 = 0 ;
50814 int res2 = 0 ;
50815 PyObject * obj0 = 0 ;
50816 PyObject * obj1 = 0 ;
50817 char * kwnames[] = {
50818 (char *) "self",(char *) "window", NULL
50819 };
50820
50821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
50822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50823 if (!SWIG_IsOK(res1)) {
50824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
50825 }
50826 arg1 = reinterpret_cast< wxSizer * >(argp1);
50827 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50828 if (!SWIG_IsOK(res2)) {
50829 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
50830 }
50831 arg2 = reinterpret_cast< wxWindow * >(argp2);
50832 {
50833 PyThreadState* __tstate = wxPyBeginAllowThreads();
50834 (arg1)->SetVirtualSizeHints(arg2);
50835 wxPyEndAllowThreads(__tstate);
50836 if (PyErr_Occurred()) SWIG_fail;
50837 }
50838 resultobj = SWIG_Py_Void();
50839 return resultobj;
50840 fail:
50841 return NULL;
50842 }
50843
50844
50845 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50846 PyObject *resultobj = 0;
50847 wxSizer *arg1 = (wxSizer *) 0 ;
50848 bool arg2 = (bool) false ;
50849 void *argp1 = 0 ;
50850 int res1 = 0 ;
50851 bool val2 ;
50852 int ecode2 = 0 ;
50853 PyObject * obj0 = 0 ;
50854 PyObject * obj1 = 0 ;
50855 char * kwnames[] = {
50856 (char *) "self",(char *) "deleteWindows", NULL
50857 };
50858
50859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
50860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50861 if (!SWIG_IsOK(res1)) {
50862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
50863 }
50864 arg1 = reinterpret_cast< wxSizer * >(argp1);
50865 if (obj1) {
50866 ecode2 = SWIG_AsVal_bool(obj1, &val2);
50867 if (!SWIG_IsOK(ecode2)) {
50868 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
50869 }
50870 arg2 = static_cast< bool >(val2);
50871 }
50872 {
50873 PyThreadState* __tstate = wxPyBeginAllowThreads();
50874 (arg1)->Clear(arg2);
50875 wxPyEndAllowThreads(__tstate);
50876 if (PyErr_Occurred()) SWIG_fail;
50877 }
50878 resultobj = SWIG_Py_Void();
50879 return resultobj;
50880 fail:
50881 return NULL;
50882 }
50883
50884
50885 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50886 PyObject *resultobj = 0;
50887 wxSizer *arg1 = (wxSizer *) 0 ;
50888 void *argp1 = 0 ;
50889 int res1 = 0 ;
50890 PyObject *swig_obj[1] ;
50891
50892 if (!args) SWIG_fail;
50893 swig_obj[0] = args;
50894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50895 if (!SWIG_IsOK(res1)) {
50896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
50897 }
50898 arg1 = reinterpret_cast< wxSizer * >(argp1);
50899 {
50900 PyThreadState* __tstate = wxPyBeginAllowThreads();
50901 (arg1)->DeleteWindows();
50902 wxPyEndAllowThreads(__tstate);
50903 if (PyErr_Occurred()) SWIG_fail;
50904 }
50905 resultobj = SWIG_Py_Void();
50906 return resultobj;
50907 fail:
50908 return NULL;
50909 }
50910
50911
50912 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50913 PyObject *resultobj = 0;
50914 wxSizer *arg1 = (wxSizer *) 0 ;
50915 PyObject *result = 0 ;
50916 void *argp1 = 0 ;
50917 int res1 = 0 ;
50918 PyObject *swig_obj[1] ;
50919
50920 if (!args) SWIG_fail;
50921 swig_obj[0] = args;
50922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50923 if (!SWIG_IsOK(res1)) {
50924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
50925 }
50926 arg1 = reinterpret_cast< wxSizer * >(argp1);
50927 {
50928 PyThreadState* __tstate = wxPyBeginAllowThreads();
50929 result = (PyObject *)wxSizer_GetChildren(arg1);
50930 wxPyEndAllowThreads(__tstate);
50931 if (PyErr_Occurred()) SWIG_fail;
50932 }
50933 resultobj = result;
50934 return resultobj;
50935 fail:
50936 return NULL;
50937 }
50938
50939
50940 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50941 PyObject *resultobj = 0;
50942 wxSizer *arg1 = (wxSizer *) 0 ;
50943 PyObject *arg2 = (PyObject *) 0 ;
50944 bool arg3 = (bool) true ;
50945 bool arg4 = (bool) false ;
50946 bool result;
50947 void *argp1 = 0 ;
50948 int res1 = 0 ;
50949 bool val3 ;
50950 int ecode3 = 0 ;
50951 bool val4 ;
50952 int ecode4 = 0 ;
50953 PyObject * obj0 = 0 ;
50954 PyObject * obj1 = 0 ;
50955 PyObject * obj2 = 0 ;
50956 PyObject * obj3 = 0 ;
50957 char * kwnames[] = {
50958 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
50959 };
50960
50961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50963 if (!SWIG_IsOK(res1)) {
50964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
50965 }
50966 arg1 = reinterpret_cast< wxSizer * >(argp1);
50967 arg2 = obj1;
50968 if (obj2) {
50969 ecode3 = SWIG_AsVal_bool(obj2, &val3);
50970 if (!SWIG_IsOK(ecode3)) {
50971 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
50972 }
50973 arg3 = static_cast< bool >(val3);
50974 }
50975 if (obj3) {
50976 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50977 if (!SWIG_IsOK(ecode4)) {
50978 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
50979 }
50980 arg4 = static_cast< bool >(val4);
50981 }
50982 {
50983 PyThreadState* __tstate = wxPyBeginAllowThreads();
50984 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
50985 wxPyEndAllowThreads(__tstate);
50986 if (PyErr_Occurred()) SWIG_fail;
50987 }
50988 {
50989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50990 }
50991 return resultobj;
50992 fail:
50993 return NULL;
50994 }
50995
50996
50997 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50998 PyObject *resultobj = 0;
50999 wxSizer *arg1 = (wxSizer *) 0 ;
51000 PyObject *arg2 = (PyObject *) 0 ;
51001 bool result;
51002 void *argp1 = 0 ;
51003 int res1 = 0 ;
51004 PyObject * obj0 = 0 ;
51005 PyObject * obj1 = 0 ;
51006 char * kwnames[] = {
51007 (char *) "self",(char *) "item", NULL
51008 };
51009
51010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
51011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51012 if (!SWIG_IsOK(res1)) {
51013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
51014 }
51015 arg1 = reinterpret_cast< wxSizer * >(argp1);
51016 arg2 = obj1;
51017 {
51018 PyThreadState* __tstate = wxPyBeginAllowThreads();
51019 result = (bool)wxSizer_IsShown(arg1,arg2);
51020 wxPyEndAllowThreads(__tstate);
51021 if (PyErr_Occurred()) SWIG_fail;
51022 }
51023 {
51024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51025 }
51026 return resultobj;
51027 fail:
51028 return NULL;
51029 }
51030
51031
51032 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51033 PyObject *resultobj = 0;
51034 wxSizer *arg1 = (wxSizer *) 0 ;
51035 bool arg2 ;
51036 void *argp1 = 0 ;
51037 int res1 = 0 ;
51038 bool val2 ;
51039 int ecode2 = 0 ;
51040 PyObject * obj0 = 0 ;
51041 PyObject * obj1 = 0 ;
51042 char * kwnames[] = {
51043 (char *) "self",(char *) "show", NULL
51044 };
51045
51046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
51047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51048 if (!SWIG_IsOK(res1)) {
51049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
51050 }
51051 arg1 = reinterpret_cast< wxSizer * >(argp1);
51052 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51053 if (!SWIG_IsOK(ecode2)) {
51054 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
51055 }
51056 arg2 = static_cast< bool >(val2);
51057 {
51058 PyThreadState* __tstate = wxPyBeginAllowThreads();
51059 (arg1)->ShowItems(arg2);
51060 wxPyEndAllowThreads(__tstate);
51061 if (PyErr_Occurred()) SWIG_fail;
51062 }
51063 resultobj = SWIG_Py_Void();
51064 return resultobj;
51065 fail:
51066 return NULL;
51067 }
51068
51069
51070 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51071 PyObject *obj;
51072 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51073 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
51074 return SWIG_Py_Void();
51075 }
51076
51077 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51078 PyObject *resultobj = 0;
51079 wxPySizer *result = 0 ;
51080
51081 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
51082 {
51083 PyThreadState* __tstate = wxPyBeginAllowThreads();
51084 result = (wxPySizer *)new wxPySizer();
51085 wxPyEndAllowThreads(__tstate);
51086 if (PyErr_Occurred()) SWIG_fail;
51087 }
51088 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
51089 return resultobj;
51090 fail:
51091 return NULL;
51092 }
51093
51094
51095 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51096 PyObject *resultobj = 0;
51097 wxPySizer *arg1 = (wxPySizer *) 0 ;
51098 PyObject *arg2 = (PyObject *) 0 ;
51099 PyObject *arg3 = (PyObject *) 0 ;
51100 void *argp1 = 0 ;
51101 int res1 = 0 ;
51102 PyObject * obj0 = 0 ;
51103 PyObject * obj1 = 0 ;
51104 PyObject * obj2 = 0 ;
51105 char * kwnames[] = {
51106 (char *) "self",(char *) "self",(char *) "_class", NULL
51107 };
51108
51109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
51111 if (!SWIG_IsOK(res1)) {
51112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
51113 }
51114 arg1 = reinterpret_cast< wxPySizer * >(argp1);
51115 arg2 = obj1;
51116 arg3 = obj2;
51117 {
51118 PyThreadState* __tstate = wxPyBeginAllowThreads();
51119 (arg1)->_setCallbackInfo(arg2,arg3);
51120 wxPyEndAllowThreads(__tstate);
51121 if (PyErr_Occurred()) SWIG_fail;
51122 }
51123 resultobj = SWIG_Py_Void();
51124 return resultobj;
51125 fail:
51126 return NULL;
51127 }
51128
51129
51130 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51131 PyObject *obj;
51132 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51133 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
51134 return SWIG_Py_Void();
51135 }
51136
51137 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51138 return SWIG_Python_InitShadowInstance(args);
51139 }
51140
51141 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51142 PyObject *resultobj = 0;
51143 int arg1 = (int) wxHORIZONTAL ;
51144 wxBoxSizer *result = 0 ;
51145 int val1 ;
51146 int ecode1 = 0 ;
51147 PyObject * obj0 = 0 ;
51148 char * kwnames[] = {
51149 (char *) "orient", NULL
51150 };
51151
51152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
51153 if (obj0) {
51154 ecode1 = SWIG_AsVal_int(obj0, &val1);
51155 if (!SWIG_IsOK(ecode1)) {
51156 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
51157 }
51158 arg1 = static_cast< int >(val1);
51159 }
51160 {
51161 PyThreadState* __tstate = wxPyBeginAllowThreads();
51162 result = (wxBoxSizer *)new wxBoxSizer(arg1);
51163 wxPyEndAllowThreads(__tstate);
51164 if (PyErr_Occurred()) SWIG_fail;
51165 }
51166 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
51167 return resultobj;
51168 fail:
51169 return NULL;
51170 }
51171
51172
51173 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51174 PyObject *resultobj = 0;
51175 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51176 int result;
51177 void *argp1 = 0 ;
51178 int res1 = 0 ;
51179 PyObject *swig_obj[1] ;
51180
51181 if (!args) SWIG_fail;
51182 swig_obj[0] = args;
51183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51184 if (!SWIG_IsOK(res1)) {
51185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51186 }
51187 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51188 {
51189 PyThreadState* __tstate = wxPyBeginAllowThreads();
51190 result = (int)(arg1)->GetOrientation();
51191 wxPyEndAllowThreads(__tstate);
51192 if (PyErr_Occurred()) SWIG_fail;
51193 }
51194 resultobj = SWIG_From_int(static_cast< int >(result));
51195 return resultobj;
51196 fail:
51197 return NULL;
51198 }
51199
51200
51201 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51202 PyObject *resultobj = 0;
51203 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51204 int arg2 ;
51205 void *argp1 = 0 ;
51206 int res1 = 0 ;
51207 int val2 ;
51208 int ecode2 = 0 ;
51209 PyObject * obj0 = 0 ;
51210 PyObject * obj1 = 0 ;
51211 char * kwnames[] = {
51212 (char *) "self",(char *) "orient", NULL
51213 };
51214
51215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
51216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51217 if (!SWIG_IsOK(res1)) {
51218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51219 }
51220 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51221 ecode2 = SWIG_AsVal_int(obj1, &val2);
51222 if (!SWIG_IsOK(ecode2)) {
51223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
51224 }
51225 arg2 = static_cast< int >(val2);
51226 {
51227 PyThreadState* __tstate = wxPyBeginAllowThreads();
51228 (arg1)->SetOrientation(arg2);
51229 wxPyEndAllowThreads(__tstate);
51230 if (PyErr_Occurred()) SWIG_fail;
51231 }
51232 resultobj = SWIG_Py_Void();
51233 return resultobj;
51234 fail:
51235 return NULL;
51236 }
51237
51238
51239 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51240 PyObject *obj;
51241 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51242 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
51243 return SWIG_Py_Void();
51244 }
51245
51246 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51247 return SWIG_Python_InitShadowInstance(args);
51248 }
51249
51250 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51251 PyObject *resultobj = 0;
51252 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
51253 int arg2 = (int) wxHORIZONTAL ;
51254 wxStaticBoxSizer *result = 0 ;
51255 void *argp1 = 0 ;
51256 int res1 = 0 ;
51257 int val2 ;
51258 int ecode2 = 0 ;
51259 PyObject * obj0 = 0 ;
51260 PyObject * obj1 = 0 ;
51261 char * kwnames[] = {
51262 (char *) "box",(char *) "orient", NULL
51263 };
51264
51265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
51267 if (!SWIG_IsOK(res1)) {
51268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
51269 }
51270 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
51271 if (obj1) {
51272 ecode2 = SWIG_AsVal_int(obj1, &val2);
51273 if (!SWIG_IsOK(ecode2)) {
51274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
51275 }
51276 arg2 = static_cast< int >(val2);
51277 }
51278 {
51279 PyThreadState* __tstate = wxPyBeginAllowThreads();
51280 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
51281 wxPyEndAllowThreads(__tstate);
51282 if (PyErr_Occurred()) SWIG_fail;
51283 }
51284 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
51285 return resultobj;
51286 fail:
51287 return NULL;
51288 }
51289
51290
51291 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51292 PyObject *resultobj = 0;
51293 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
51294 wxStaticBox *result = 0 ;
51295 void *argp1 = 0 ;
51296 int res1 = 0 ;
51297 PyObject *swig_obj[1] ;
51298
51299 if (!args) SWIG_fail;
51300 swig_obj[0] = args;
51301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
51302 if (!SWIG_IsOK(res1)) {
51303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
51304 }
51305 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
51306 {
51307 PyThreadState* __tstate = wxPyBeginAllowThreads();
51308 result = (wxStaticBox *)(arg1)->GetStaticBox();
51309 wxPyEndAllowThreads(__tstate);
51310 if (PyErr_Occurred()) SWIG_fail;
51311 }
51312 {
51313 resultobj = wxPyMake_wxObject(result, (bool)0);
51314 }
51315 return resultobj;
51316 fail:
51317 return NULL;
51318 }
51319
51320
51321 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51322 PyObject *obj;
51323 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51324 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
51325 return SWIG_Py_Void();
51326 }
51327
51328 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51329 return SWIG_Python_InitShadowInstance(args);
51330 }
51331
51332 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51333 PyObject *resultobj = 0;
51334 int arg1 = (int) 1 ;
51335 int arg2 = (int) 0 ;
51336 int arg3 = (int) 0 ;
51337 int arg4 = (int) 0 ;
51338 wxGridSizer *result = 0 ;
51339 int val1 ;
51340 int ecode1 = 0 ;
51341 int val2 ;
51342 int ecode2 = 0 ;
51343 int val3 ;
51344 int ecode3 = 0 ;
51345 int val4 ;
51346 int ecode4 = 0 ;
51347 PyObject * obj0 = 0 ;
51348 PyObject * obj1 = 0 ;
51349 PyObject * obj2 = 0 ;
51350 PyObject * obj3 = 0 ;
51351 char * kwnames[] = {
51352 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51353 };
51354
51355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51356 if (obj0) {
51357 ecode1 = SWIG_AsVal_int(obj0, &val1);
51358 if (!SWIG_IsOK(ecode1)) {
51359 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
51360 }
51361 arg1 = static_cast< int >(val1);
51362 }
51363 if (obj1) {
51364 ecode2 = SWIG_AsVal_int(obj1, &val2);
51365 if (!SWIG_IsOK(ecode2)) {
51366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
51367 }
51368 arg2 = static_cast< int >(val2);
51369 }
51370 if (obj2) {
51371 ecode3 = SWIG_AsVal_int(obj2, &val3);
51372 if (!SWIG_IsOK(ecode3)) {
51373 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
51374 }
51375 arg3 = static_cast< int >(val3);
51376 }
51377 if (obj3) {
51378 ecode4 = SWIG_AsVal_int(obj3, &val4);
51379 if (!SWIG_IsOK(ecode4)) {
51380 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
51381 }
51382 arg4 = static_cast< int >(val4);
51383 }
51384 {
51385 PyThreadState* __tstate = wxPyBeginAllowThreads();
51386 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
51387 wxPyEndAllowThreads(__tstate);
51388 if (PyErr_Occurred()) SWIG_fail;
51389 }
51390 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
51391 return resultobj;
51392 fail:
51393 return NULL;
51394 }
51395
51396
51397 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51398 PyObject *resultobj = 0;
51399 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51400 int arg2 ;
51401 void *argp1 = 0 ;
51402 int res1 = 0 ;
51403 int val2 ;
51404 int ecode2 = 0 ;
51405 PyObject * obj0 = 0 ;
51406 PyObject * obj1 = 0 ;
51407 char * kwnames[] = {
51408 (char *) "self",(char *) "cols", NULL
51409 };
51410
51411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
51412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51413 if (!SWIG_IsOK(res1)) {
51414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51415 }
51416 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51417 ecode2 = SWIG_AsVal_int(obj1, &val2);
51418 if (!SWIG_IsOK(ecode2)) {
51419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
51420 }
51421 arg2 = static_cast< int >(val2);
51422 {
51423 PyThreadState* __tstate = wxPyBeginAllowThreads();
51424 (arg1)->SetCols(arg2);
51425 wxPyEndAllowThreads(__tstate);
51426 if (PyErr_Occurred()) SWIG_fail;
51427 }
51428 resultobj = SWIG_Py_Void();
51429 return resultobj;
51430 fail:
51431 return NULL;
51432 }
51433
51434
51435 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51436 PyObject *resultobj = 0;
51437 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51438 int arg2 ;
51439 void *argp1 = 0 ;
51440 int res1 = 0 ;
51441 int val2 ;
51442 int ecode2 = 0 ;
51443 PyObject * obj0 = 0 ;
51444 PyObject * obj1 = 0 ;
51445 char * kwnames[] = {
51446 (char *) "self",(char *) "rows", NULL
51447 };
51448
51449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
51450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51451 if (!SWIG_IsOK(res1)) {
51452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51453 }
51454 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51455 ecode2 = SWIG_AsVal_int(obj1, &val2);
51456 if (!SWIG_IsOK(ecode2)) {
51457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
51458 }
51459 arg2 = static_cast< int >(val2);
51460 {
51461 PyThreadState* __tstate = wxPyBeginAllowThreads();
51462 (arg1)->SetRows(arg2);
51463 wxPyEndAllowThreads(__tstate);
51464 if (PyErr_Occurred()) SWIG_fail;
51465 }
51466 resultobj = SWIG_Py_Void();
51467 return resultobj;
51468 fail:
51469 return NULL;
51470 }
51471
51472
51473 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51474 PyObject *resultobj = 0;
51475 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51476 int arg2 ;
51477 void *argp1 = 0 ;
51478 int res1 = 0 ;
51479 int val2 ;
51480 int ecode2 = 0 ;
51481 PyObject * obj0 = 0 ;
51482 PyObject * obj1 = 0 ;
51483 char * kwnames[] = {
51484 (char *) "self",(char *) "gap", NULL
51485 };
51486
51487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
51488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51489 if (!SWIG_IsOK(res1)) {
51490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51491 }
51492 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51493 ecode2 = SWIG_AsVal_int(obj1, &val2);
51494 if (!SWIG_IsOK(ecode2)) {
51495 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
51496 }
51497 arg2 = static_cast< int >(val2);
51498 {
51499 PyThreadState* __tstate = wxPyBeginAllowThreads();
51500 (arg1)->SetVGap(arg2);
51501 wxPyEndAllowThreads(__tstate);
51502 if (PyErr_Occurred()) SWIG_fail;
51503 }
51504 resultobj = SWIG_Py_Void();
51505 return resultobj;
51506 fail:
51507 return NULL;
51508 }
51509
51510
51511 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51512 PyObject *resultobj = 0;
51513 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51514 int arg2 ;
51515 void *argp1 = 0 ;
51516 int res1 = 0 ;
51517 int val2 ;
51518 int ecode2 = 0 ;
51519 PyObject * obj0 = 0 ;
51520 PyObject * obj1 = 0 ;
51521 char * kwnames[] = {
51522 (char *) "self",(char *) "gap", NULL
51523 };
51524
51525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
51526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51527 if (!SWIG_IsOK(res1)) {
51528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51529 }
51530 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51531 ecode2 = SWIG_AsVal_int(obj1, &val2);
51532 if (!SWIG_IsOK(ecode2)) {
51533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
51534 }
51535 arg2 = static_cast< int >(val2);
51536 {
51537 PyThreadState* __tstate = wxPyBeginAllowThreads();
51538 (arg1)->SetHGap(arg2);
51539 wxPyEndAllowThreads(__tstate);
51540 if (PyErr_Occurred()) SWIG_fail;
51541 }
51542 resultobj = SWIG_Py_Void();
51543 return resultobj;
51544 fail:
51545 return NULL;
51546 }
51547
51548
51549 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51550 PyObject *resultobj = 0;
51551 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51552 int result;
51553 void *argp1 = 0 ;
51554 int res1 = 0 ;
51555 PyObject *swig_obj[1] ;
51556
51557 if (!args) SWIG_fail;
51558 swig_obj[0] = args;
51559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51560 if (!SWIG_IsOK(res1)) {
51561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51562 }
51563 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51564 {
51565 PyThreadState* __tstate = wxPyBeginAllowThreads();
51566 result = (int)(arg1)->GetCols();
51567 wxPyEndAllowThreads(__tstate);
51568 if (PyErr_Occurred()) SWIG_fail;
51569 }
51570 resultobj = SWIG_From_int(static_cast< int >(result));
51571 return resultobj;
51572 fail:
51573 return NULL;
51574 }
51575
51576
51577 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51578 PyObject *resultobj = 0;
51579 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51580 int result;
51581 void *argp1 = 0 ;
51582 int res1 = 0 ;
51583 PyObject *swig_obj[1] ;
51584
51585 if (!args) SWIG_fail;
51586 swig_obj[0] = args;
51587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51588 if (!SWIG_IsOK(res1)) {
51589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51590 }
51591 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51592 {
51593 PyThreadState* __tstate = wxPyBeginAllowThreads();
51594 result = (int)(arg1)->GetRows();
51595 wxPyEndAllowThreads(__tstate);
51596 if (PyErr_Occurred()) SWIG_fail;
51597 }
51598 resultobj = SWIG_From_int(static_cast< int >(result));
51599 return resultobj;
51600 fail:
51601 return NULL;
51602 }
51603
51604
51605 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51606 PyObject *resultobj = 0;
51607 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51608 int result;
51609 void *argp1 = 0 ;
51610 int res1 = 0 ;
51611 PyObject *swig_obj[1] ;
51612
51613 if (!args) SWIG_fail;
51614 swig_obj[0] = args;
51615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51616 if (!SWIG_IsOK(res1)) {
51617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51618 }
51619 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51620 {
51621 PyThreadState* __tstate = wxPyBeginAllowThreads();
51622 result = (int)(arg1)->GetVGap();
51623 wxPyEndAllowThreads(__tstate);
51624 if (PyErr_Occurred()) SWIG_fail;
51625 }
51626 resultobj = SWIG_From_int(static_cast< int >(result));
51627 return resultobj;
51628 fail:
51629 return NULL;
51630 }
51631
51632
51633 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51634 PyObject *resultobj = 0;
51635 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51636 int result;
51637 void *argp1 = 0 ;
51638 int res1 = 0 ;
51639 PyObject *swig_obj[1] ;
51640
51641 if (!args) SWIG_fail;
51642 swig_obj[0] = args;
51643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51644 if (!SWIG_IsOK(res1)) {
51645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51646 }
51647 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51648 {
51649 PyThreadState* __tstate = wxPyBeginAllowThreads();
51650 result = (int)(arg1)->GetHGap();
51651 wxPyEndAllowThreads(__tstate);
51652 if (PyErr_Occurred()) SWIG_fail;
51653 }
51654 resultobj = SWIG_From_int(static_cast< int >(result));
51655 return resultobj;
51656 fail:
51657 return NULL;
51658 }
51659
51660
51661 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51662 PyObject *obj;
51663 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51664 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
51665 return SWIG_Py_Void();
51666 }
51667
51668 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51669 return SWIG_Python_InitShadowInstance(args);
51670 }
51671
51672 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51673 PyObject *resultobj = 0;
51674 int arg1 = (int) 1 ;
51675 int arg2 = (int) 0 ;
51676 int arg3 = (int) 0 ;
51677 int arg4 = (int) 0 ;
51678 wxFlexGridSizer *result = 0 ;
51679 int val1 ;
51680 int ecode1 = 0 ;
51681 int val2 ;
51682 int ecode2 = 0 ;
51683 int val3 ;
51684 int ecode3 = 0 ;
51685 int val4 ;
51686 int ecode4 = 0 ;
51687 PyObject * obj0 = 0 ;
51688 PyObject * obj1 = 0 ;
51689 PyObject * obj2 = 0 ;
51690 PyObject * obj3 = 0 ;
51691 char * kwnames[] = {
51692 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51693 };
51694
51695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51696 if (obj0) {
51697 ecode1 = SWIG_AsVal_int(obj0, &val1);
51698 if (!SWIG_IsOK(ecode1)) {
51699 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
51700 }
51701 arg1 = static_cast< int >(val1);
51702 }
51703 if (obj1) {
51704 ecode2 = SWIG_AsVal_int(obj1, &val2);
51705 if (!SWIG_IsOK(ecode2)) {
51706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
51707 }
51708 arg2 = static_cast< int >(val2);
51709 }
51710 if (obj2) {
51711 ecode3 = SWIG_AsVal_int(obj2, &val3);
51712 if (!SWIG_IsOK(ecode3)) {
51713 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
51714 }
51715 arg3 = static_cast< int >(val3);
51716 }
51717 if (obj3) {
51718 ecode4 = SWIG_AsVal_int(obj3, &val4);
51719 if (!SWIG_IsOK(ecode4)) {
51720 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
51721 }
51722 arg4 = static_cast< int >(val4);
51723 }
51724 {
51725 PyThreadState* __tstate = wxPyBeginAllowThreads();
51726 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
51727 wxPyEndAllowThreads(__tstate);
51728 if (PyErr_Occurred()) SWIG_fail;
51729 }
51730 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
51731 return resultobj;
51732 fail:
51733 return NULL;
51734 }
51735
51736
51737 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51738 PyObject *resultobj = 0;
51739 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51740 size_t arg2 ;
51741 int arg3 = (int) 0 ;
51742 void *argp1 = 0 ;
51743 int res1 = 0 ;
51744 size_t val2 ;
51745 int ecode2 = 0 ;
51746 int val3 ;
51747 int ecode3 = 0 ;
51748 PyObject * obj0 = 0 ;
51749 PyObject * obj1 = 0 ;
51750 PyObject * obj2 = 0 ;
51751 char * kwnames[] = {
51752 (char *) "self",(char *) "idx",(char *) "proportion", NULL
51753 };
51754
51755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51757 if (!SWIG_IsOK(res1)) {
51758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51759 }
51760 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51761 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51762 if (!SWIG_IsOK(ecode2)) {
51763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
51764 }
51765 arg2 = static_cast< size_t >(val2);
51766 if (obj2) {
51767 ecode3 = SWIG_AsVal_int(obj2, &val3);
51768 if (!SWIG_IsOK(ecode3)) {
51769 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
51770 }
51771 arg3 = static_cast< int >(val3);
51772 }
51773 {
51774 PyThreadState* __tstate = wxPyBeginAllowThreads();
51775 (arg1)->AddGrowableRow(arg2,arg3);
51776 wxPyEndAllowThreads(__tstate);
51777 if (PyErr_Occurred()) SWIG_fail;
51778 }
51779 resultobj = SWIG_Py_Void();
51780 return resultobj;
51781 fail:
51782 return NULL;
51783 }
51784
51785
51786 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51787 PyObject *resultobj = 0;
51788 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51789 size_t arg2 ;
51790 void *argp1 = 0 ;
51791 int res1 = 0 ;
51792 size_t val2 ;
51793 int ecode2 = 0 ;
51794 PyObject * obj0 = 0 ;
51795 PyObject * obj1 = 0 ;
51796 char * kwnames[] = {
51797 (char *) "self",(char *) "idx", NULL
51798 };
51799
51800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
51801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51802 if (!SWIG_IsOK(res1)) {
51803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51804 }
51805 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51806 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51807 if (!SWIG_IsOK(ecode2)) {
51808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
51809 }
51810 arg2 = static_cast< size_t >(val2);
51811 {
51812 PyThreadState* __tstate = wxPyBeginAllowThreads();
51813 (arg1)->RemoveGrowableRow(arg2);
51814 wxPyEndAllowThreads(__tstate);
51815 if (PyErr_Occurred()) SWIG_fail;
51816 }
51817 resultobj = SWIG_Py_Void();
51818 return resultobj;
51819 fail:
51820 return NULL;
51821 }
51822
51823
51824 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51825 PyObject *resultobj = 0;
51826 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51827 size_t arg2 ;
51828 int arg3 = (int) 0 ;
51829 void *argp1 = 0 ;
51830 int res1 = 0 ;
51831 size_t val2 ;
51832 int ecode2 = 0 ;
51833 int val3 ;
51834 int ecode3 = 0 ;
51835 PyObject * obj0 = 0 ;
51836 PyObject * obj1 = 0 ;
51837 PyObject * obj2 = 0 ;
51838 char * kwnames[] = {
51839 (char *) "self",(char *) "idx",(char *) "proportion", NULL
51840 };
51841
51842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51844 if (!SWIG_IsOK(res1)) {
51845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51846 }
51847 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51848 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51849 if (!SWIG_IsOK(ecode2)) {
51850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
51851 }
51852 arg2 = static_cast< size_t >(val2);
51853 if (obj2) {
51854 ecode3 = SWIG_AsVal_int(obj2, &val3);
51855 if (!SWIG_IsOK(ecode3)) {
51856 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
51857 }
51858 arg3 = static_cast< int >(val3);
51859 }
51860 {
51861 PyThreadState* __tstate = wxPyBeginAllowThreads();
51862 (arg1)->AddGrowableCol(arg2,arg3);
51863 wxPyEndAllowThreads(__tstate);
51864 if (PyErr_Occurred()) SWIG_fail;
51865 }
51866 resultobj = SWIG_Py_Void();
51867 return resultobj;
51868 fail:
51869 return NULL;
51870 }
51871
51872
51873 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51874 PyObject *resultobj = 0;
51875 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51876 size_t arg2 ;
51877 void *argp1 = 0 ;
51878 int res1 = 0 ;
51879 size_t val2 ;
51880 int ecode2 = 0 ;
51881 PyObject * obj0 = 0 ;
51882 PyObject * obj1 = 0 ;
51883 char * kwnames[] = {
51884 (char *) "self",(char *) "idx", NULL
51885 };
51886
51887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
51888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51889 if (!SWIG_IsOK(res1)) {
51890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51891 }
51892 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51893 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51894 if (!SWIG_IsOK(ecode2)) {
51895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
51896 }
51897 arg2 = static_cast< size_t >(val2);
51898 {
51899 PyThreadState* __tstate = wxPyBeginAllowThreads();
51900 (arg1)->RemoveGrowableCol(arg2);
51901 wxPyEndAllowThreads(__tstate);
51902 if (PyErr_Occurred()) SWIG_fail;
51903 }
51904 resultobj = SWIG_Py_Void();
51905 return resultobj;
51906 fail:
51907 return NULL;
51908 }
51909
51910
51911 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51912 PyObject *resultobj = 0;
51913 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51914 int arg2 ;
51915 void *argp1 = 0 ;
51916 int res1 = 0 ;
51917 int val2 ;
51918 int ecode2 = 0 ;
51919 PyObject * obj0 = 0 ;
51920 PyObject * obj1 = 0 ;
51921 char * kwnames[] = {
51922 (char *) "self",(char *) "direction", NULL
51923 };
51924
51925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
51926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51927 if (!SWIG_IsOK(res1)) {
51928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51929 }
51930 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51931 ecode2 = SWIG_AsVal_int(obj1, &val2);
51932 if (!SWIG_IsOK(ecode2)) {
51933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
51934 }
51935 arg2 = static_cast< int >(val2);
51936 {
51937 PyThreadState* __tstate = wxPyBeginAllowThreads();
51938 (arg1)->SetFlexibleDirection(arg2);
51939 wxPyEndAllowThreads(__tstate);
51940 if (PyErr_Occurred()) SWIG_fail;
51941 }
51942 resultobj = SWIG_Py_Void();
51943 return resultobj;
51944 fail:
51945 return NULL;
51946 }
51947
51948
51949 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51950 PyObject *resultobj = 0;
51951 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51952 int result;
51953 void *argp1 = 0 ;
51954 int res1 = 0 ;
51955 PyObject *swig_obj[1] ;
51956
51957 if (!args) SWIG_fail;
51958 swig_obj[0] = args;
51959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51960 if (!SWIG_IsOK(res1)) {
51961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51962 }
51963 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51964 {
51965 PyThreadState* __tstate = wxPyBeginAllowThreads();
51966 result = (int)(arg1)->GetFlexibleDirection();
51967 wxPyEndAllowThreads(__tstate);
51968 if (PyErr_Occurred()) SWIG_fail;
51969 }
51970 resultobj = SWIG_From_int(static_cast< int >(result));
51971 return resultobj;
51972 fail:
51973 return NULL;
51974 }
51975
51976
51977 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51978 PyObject *resultobj = 0;
51979 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51980 wxFlexSizerGrowMode arg2 ;
51981 void *argp1 = 0 ;
51982 int res1 = 0 ;
51983 int val2 ;
51984 int ecode2 = 0 ;
51985 PyObject * obj0 = 0 ;
51986 PyObject * obj1 = 0 ;
51987 char * kwnames[] = {
51988 (char *) "self",(char *) "mode", NULL
51989 };
51990
51991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
51992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51993 if (!SWIG_IsOK(res1)) {
51994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51995 }
51996 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51997 ecode2 = SWIG_AsVal_int(obj1, &val2);
51998 if (!SWIG_IsOK(ecode2)) {
51999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
52000 }
52001 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
52002 {
52003 PyThreadState* __tstate = wxPyBeginAllowThreads();
52004 (arg1)->SetNonFlexibleGrowMode(arg2);
52005 wxPyEndAllowThreads(__tstate);
52006 if (PyErr_Occurred()) SWIG_fail;
52007 }
52008 resultobj = SWIG_Py_Void();
52009 return resultobj;
52010 fail:
52011 return NULL;
52012 }
52013
52014
52015 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52016 PyObject *resultobj = 0;
52017 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52018 wxFlexSizerGrowMode result;
52019 void *argp1 = 0 ;
52020 int res1 = 0 ;
52021 PyObject *swig_obj[1] ;
52022
52023 if (!args) SWIG_fail;
52024 swig_obj[0] = args;
52025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52026 if (!SWIG_IsOK(res1)) {
52027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52028 }
52029 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52030 {
52031 PyThreadState* __tstate = wxPyBeginAllowThreads();
52032 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
52033 wxPyEndAllowThreads(__tstate);
52034 if (PyErr_Occurred()) SWIG_fail;
52035 }
52036 resultobj = SWIG_From_int(static_cast< int >(result));
52037 return resultobj;
52038 fail:
52039 return NULL;
52040 }
52041
52042
52043 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52044 PyObject *resultobj = 0;
52045 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52046 wxArrayInt *result = 0 ;
52047 void *argp1 = 0 ;
52048 int res1 = 0 ;
52049 PyObject *swig_obj[1] ;
52050
52051 if (!args) SWIG_fail;
52052 swig_obj[0] = args;
52053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52054 if (!SWIG_IsOK(res1)) {
52055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52056 }
52057 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52058 {
52059 PyThreadState* __tstate = wxPyBeginAllowThreads();
52060 {
52061 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
52062 result = (wxArrayInt *) &_result_ref;
52063 }
52064 wxPyEndAllowThreads(__tstate);
52065 if (PyErr_Occurred()) SWIG_fail;
52066 }
52067 {
52068 resultobj = wxArrayInt2PyList_helper(*result);
52069 }
52070 return resultobj;
52071 fail:
52072 return NULL;
52073 }
52074
52075
52076 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52077 PyObject *resultobj = 0;
52078 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52079 wxArrayInt *result = 0 ;
52080 void *argp1 = 0 ;
52081 int res1 = 0 ;
52082 PyObject *swig_obj[1] ;
52083
52084 if (!args) SWIG_fail;
52085 swig_obj[0] = args;
52086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52087 if (!SWIG_IsOK(res1)) {
52088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52089 }
52090 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52091 {
52092 PyThreadState* __tstate = wxPyBeginAllowThreads();
52093 {
52094 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
52095 result = (wxArrayInt *) &_result_ref;
52096 }
52097 wxPyEndAllowThreads(__tstate);
52098 if (PyErr_Occurred()) SWIG_fail;
52099 }
52100 {
52101 resultobj = wxArrayInt2PyList_helper(*result);
52102 }
52103 return resultobj;
52104 fail:
52105 return NULL;
52106 }
52107
52108
52109 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52110 PyObject *obj;
52111 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52112 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
52113 return SWIG_Py_Void();
52114 }
52115
52116 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52117 return SWIG_Python_InitShadowInstance(args);
52118 }
52119
52120 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52121 PyObject *resultobj = 0;
52122 wxStdDialogButtonSizer *result = 0 ;
52123
52124 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
52125 {
52126 PyThreadState* __tstate = wxPyBeginAllowThreads();
52127 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
52128 wxPyEndAllowThreads(__tstate);
52129 if (PyErr_Occurred()) SWIG_fail;
52130 }
52131 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
52132 return resultobj;
52133 fail:
52134 return NULL;
52135 }
52136
52137
52138 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52139 PyObject *resultobj = 0;
52140 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52141 wxButton *arg2 = (wxButton *) 0 ;
52142 void *argp1 = 0 ;
52143 int res1 = 0 ;
52144 void *argp2 = 0 ;
52145 int res2 = 0 ;
52146 PyObject * obj0 = 0 ;
52147 PyObject * obj1 = 0 ;
52148 char * kwnames[] = {
52149 (char *) "self",(char *) "button", NULL
52150 };
52151
52152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
52153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52154 if (!SWIG_IsOK(res1)) {
52155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52156 }
52157 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52158 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52159 if (!SWIG_IsOK(res2)) {
52160 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
52161 }
52162 arg2 = reinterpret_cast< wxButton * >(argp2);
52163 {
52164 PyThreadState* __tstate = wxPyBeginAllowThreads();
52165 (arg1)->AddButton(arg2);
52166 wxPyEndAllowThreads(__tstate);
52167 if (PyErr_Occurred()) SWIG_fail;
52168 }
52169 resultobj = SWIG_Py_Void();
52170 return resultobj;
52171 fail:
52172 return NULL;
52173 }
52174
52175
52176 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52177 PyObject *resultobj = 0;
52178 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52179 void *argp1 = 0 ;
52180 int res1 = 0 ;
52181 PyObject *swig_obj[1] ;
52182
52183 if (!args) SWIG_fail;
52184 swig_obj[0] = args;
52185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52186 if (!SWIG_IsOK(res1)) {
52187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52188 }
52189 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52190 {
52191 PyThreadState* __tstate = wxPyBeginAllowThreads();
52192 (arg1)->Realize();
52193 wxPyEndAllowThreads(__tstate);
52194 if (PyErr_Occurred()) SWIG_fail;
52195 }
52196 resultobj = SWIG_Py_Void();
52197 return resultobj;
52198 fail:
52199 return NULL;
52200 }
52201
52202
52203 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52204 PyObject *resultobj = 0;
52205 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52206 wxButton *arg2 = (wxButton *) 0 ;
52207 void *argp1 = 0 ;
52208 int res1 = 0 ;
52209 void *argp2 = 0 ;
52210 int res2 = 0 ;
52211 PyObject * obj0 = 0 ;
52212 PyObject * obj1 = 0 ;
52213 char * kwnames[] = {
52214 (char *) "self",(char *) "button", NULL
52215 };
52216
52217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52219 if (!SWIG_IsOK(res1)) {
52220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52221 }
52222 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52223 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52224 if (!SWIG_IsOK(res2)) {
52225 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52226 }
52227 arg2 = reinterpret_cast< wxButton * >(argp2);
52228 {
52229 PyThreadState* __tstate = wxPyBeginAllowThreads();
52230 (arg1)->SetAffirmativeButton(arg2);
52231 wxPyEndAllowThreads(__tstate);
52232 if (PyErr_Occurred()) SWIG_fail;
52233 }
52234 resultobj = SWIG_Py_Void();
52235 return resultobj;
52236 fail:
52237 return NULL;
52238 }
52239
52240
52241 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52242 PyObject *resultobj = 0;
52243 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52244 wxButton *arg2 = (wxButton *) 0 ;
52245 void *argp1 = 0 ;
52246 int res1 = 0 ;
52247 void *argp2 = 0 ;
52248 int res2 = 0 ;
52249 PyObject * obj0 = 0 ;
52250 PyObject * obj1 = 0 ;
52251 char * kwnames[] = {
52252 (char *) "self",(char *) "button", NULL
52253 };
52254
52255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52257 if (!SWIG_IsOK(res1)) {
52258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52259 }
52260 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52261 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52262 if (!SWIG_IsOK(res2)) {
52263 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52264 }
52265 arg2 = reinterpret_cast< wxButton * >(argp2);
52266 {
52267 PyThreadState* __tstate = wxPyBeginAllowThreads();
52268 (arg1)->SetNegativeButton(arg2);
52269 wxPyEndAllowThreads(__tstate);
52270 if (PyErr_Occurred()) SWIG_fail;
52271 }
52272 resultobj = SWIG_Py_Void();
52273 return resultobj;
52274 fail:
52275 return NULL;
52276 }
52277
52278
52279 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52280 PyObject *resultobj = 0;
52281 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52282 wxButton *arg2 = (wxButton *) 0 ;
52283 void *argp1 = 0 ;
52284 int res1 = 0 ;
52285 void *argp2 = 0 ;
52286 int res2 = 0 ;
52287 PyObject * obj0 = 0 ;
52288 PyObject * obj1 = 0 ;
52289 char * kwnames[] = {
52290 (char *) "self",(char *) "button", NULL
52291 };
52292
52293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
52294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52295 if (!SWIG_IsOK(res1)) {
52296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52297 }
52298 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52299 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52300 if (!SWIG_IsOK(res2)) {
52301 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
52302 }
52303 arg2 = reinterpret_cast< wxButton * >(argp2);
52304 {
52305 PyThreadState* __tstate = wxPyBeginAllowThreads();
52306 (arg1)->SetCancelButton(arg2);
52307 wxPyEndAllowThreads(__tstate);
52308 if (PyErr_Occurred()) SWIG_fail;
52309 }
52310 resultobj = SWIG_Py_Void();
52311 return resultobj;
52312 fail:
52313 return NULL;
52314 }
52315
52316
52317 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52318 PyObject *resultobj = 0;
52319 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52320 wxButton *result = 0 ;
52321 void *argp1 = 0 ;
52322 int res1 = 0 ;
52323 PyObject *swig_obj[1] ;
52324
52325 if (!args) SWIG_fail;
52326 swig_obj[0] = args;
52327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52328 if (!SWIG_IsOK(res1)) {
52329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52330 }
52331 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52332 {
52333 PyThreadState* __tstate = wxPyBeginAllowThreads();
52334 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
52335 wxPyEndAllowThreads(__tstate);
52336 if (PyErr_Occurred()) SWIG_fail;
52337 }
52338 {
52339 resultobj = wxPyMake_wxObject(result, (bool)0);
52340 }
52341 return resultobj;
52342 fail:
52343 return NULL;
52344 }
52345
52346
52347 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52348 PyObject *resultobj = 0;
52349 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52350 wxButton *result = 0 ;
52351 void *argp1 = 0 ;
52352 int res1 = 0 ;
52353 PyObject *swig_obj[1] ;
52354
52355 if (!args) SWIG_fail;
52356 swig_obj[0] = args;
52357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52358 if (!SWIG_IsOK(res1)) {
52359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52360 }
52361 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52362 {
52363 PyThreadState* __tstate = wxPyBeginAllowThreads();
52364 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
52365 wxPyEndAllowThreads(__tstate);
52366 if (PyErr_Occurred()) SWIG_fail;
52367 }
52368 {
52369 resultobj = wxPyMake_wxObject(result, (bool)0);
52370 }
52371 return resultobj;
52372 fail:
52373 return NULL;
52374 }
52375
52376
52377 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52378 PyObject *resultobj = 0;
52379 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52380 wxButton *result = 0 ;
52381 void *argp1 = 0 ;
52382 int res1 = 0 ;
52383 PyObject *swig_obj[1] ;
52384
52385 if (!args) SWIG_fail;
52386 swig_obj[0] = args;
52387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52388 if (!SWIG_IsOK(res1)) {
52389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52390 }
52391 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52392 {
52393 PyThreadState* __tstate = wxPyBeginAllowThreads();
52394 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
52395 wxPyEndAllowThreads(__tstate);
52396 if (PyErr_Occurred()) SWIG_fail;
52397 }
52398 {
52399 resultobj = wxPyMake_wxObject(result, (bool)0);
52400 }
52401 return resultobj;
52402 fail:
52403 return NULL;
52404 }
52405
52406
52407 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52408 PyObject *resultobj = 0;
52409 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52410 wxButton *result = 0 ;
52411 void *argp1 = 0 ;
52412 int res1 = 0 ;
52413 PyObject *swig_obj[1] ;
52414
52415 if (!args) SWIG_fail;
52416 swig_obj[0] = args;
52417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52418 if (!SWIG_IsOK(res1)) {
52419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52420 }
52421 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52422 {
52423 PyThreadState* __tstate = wxPyBeginAllowThreads();
52424 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
52425 wxPyEndAllowThreads(__tstate);
52426 if (PyErr_Occurred()) SWIG_fail;
52427 }
52428 {
52429 resultobj = wxPyMake_wxObject(result, (bool)0);
52430 }
52431 return resultobj;
52432 fail:
52433 return NULL;
52434 }
52435
52436
52437 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52438 PyObject *resultobj = 0;
52439 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52440 wxButton *result = 0 ;
52441 void *argp1 = 0 ;
52442 int res1 = 0 ;
52443 PyObject *swig_obj[1] ;
52444
52445 if (!args) SWIG_fail;
52446 swig_obj[0] = args;
52447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52448 if (!SWIG_IsOK(res1)) {
52449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52450 }
52451 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52452 {
52453 PyThreadState* __tstate = wxPyBeginAllowThreads();
52454 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
52455 wxPyEndAllowThreads(__tstate);
52456 if (PyErr_Occurred()) SWIG_fail;
52457 }
52458 {
52459 resultobj = wxPyMake_wxObject(result, (bool)0);
52460 }
52461 return resultobj;
52462 fail:
52463 return NULL;
52464 }
52465
52466
52467 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52468 PyObject *obj;
52469 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52470 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
52471 return SWIG_Py_Void();
52472 }
52473
52474 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52475 return SWIG_Python_InitShadowInstance(args);
52476 }
52477
52478 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52479 PyObject *resultobj = 0;
52480 int arg1 = (int) 0 ;
52481 int arg2 = (int) 0 ;
52482 wxGBPosition *result = 0 ;
52483 int val1 ;
52484 int ecode1 = 0 ;
52485 int val2 ;
52486 int ecode2 = 0 ;
52487 PyObject * obj0 = 0 ;
52488 PyObject * obj1 = 0 ;
52489 char * kwnames[] = {
52490 (char *) "row",(char *) "col", NULL
52491 };
52492
52493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52494 if (obj0) {
52495 ecode1 = SWIG_AsVal_int(obj0, &val1);
52496 if (!SWIG_IsOK(ecode1)) {
52497 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
52498 }
52499 arg1 = static_cast< int >(val1);
52500 }
52501 if (obj1) {
52502 ecode2 = SWIG_AsVal_int(obj1, &val2);
52503 if (!SWIG_IsOK(ecode2)) {
52504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
52505 }
52506 arg2 = static_cast< int >(val2);
52507 }
52508 {
52509 PyThreadState* __tstate = wxPyBeginAllowThreads();
52510 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
52511 wxPyEndAllowThreads(__tstate);
52512 if (PyErr_Occurred()) SWIG_fail;
52513 }
52514 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
52515 return resultobj;
52516 fail:
52517 return NULL;
52518 }
52519
52520
52521 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52522 PyObject *resultobj = 0;
52523 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52524 void *argp1 = 0 ;
52525 int res1 = 0 ;
52526 PyObject *swig_obj[1] ;
52527
52528 if (!args) SWIG_fail;
52529 swig_obj[0] = args;
52530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
52531 if (!SWIG_IsOK(res1)) {
52532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52533 }
52534 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52535 {
52536 PyThreadState* __tstate = wxPyBeginAllowThreads();
52537 delete arg1;
52538
52539 wxPyEndAllowThreads(__tstate);
52540 if (PyErr_Occurred()) SWIG_fail;
52541 }
52542 resultobj = SWIG_Py_Void();
52543 return resultobj;
52544 fail:
52545 return NULL;
52546 }
52547
52548
52549 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52550 PyObject *resultobj = 0;
52551 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52552 int result;
52553 void *argp1 = 0 ;
52554 int res1 = 0 ;
52555 PyObject *swig_obj[1] ;
52556
52557 if (!args) SWIG_fail;
52558 swig_obj[0] = args;
52559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52560 if (!SWIG_IsOK(res1)) {
52561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52562 }
52563 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52564 {
52565 PyThreadState* __tstate = wxPyBeginAllowThreads();
52566 result = (int)((wxGBPosition const *)arg1)->GetRow();
52567 wxPyEndAllowThreads(__tstate);
52568 if (PyErr_Occurred()) SWIG_fail;
52569 }
52570 resultobj = SWIG_From_int(static_cast< int >(result));
52571 return resultobj;
52572 fail:
52573 return NULL;
52574 }
52575
52576
52577 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52578 PyObject *resultobj = 0;
52579 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52580 int result;
52581 void *argp1 = 0 ;
52582 int res1 = 0 ;
52583 PyObject *swig_obj[1] ;
52584
52585 if (!args) SWIG_fail;
52586 swig_obj[0] = args;
52587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52588 if (!SWIG_IsOK(res1)) {
52589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52590 }
52591 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52592 {
52593 PyThreadState* __tstate = wxPyBeginAllowThreads();
52594 result = (int)((wxGBPosition const *)arg1)->GetCol();
52595 wxPyEndAllowThreads(__tstate);
52596 if (PyErr_Occurred()) SWIG_fail;
52597 }
52598 resultobj = SWIG_From_int(static_cast< int >(result));
52599 return resultobj;
52600 fail:
52601 return NULL;
52602 }
52603
52604
52605 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52606 PyObject *resultobj = 0;
52607 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52608 int arg2 ;
52609 void *argp1 = 0 ;
52610 int res1 = 0 ;
52611 int val2 ;
52612 int ecode2 = 0 ;
52613 PyObject * obj0 = 0 ;
52614 PyObject * obj1 = 0 ;
52615 char * kwnames[] = {
52616 (char *) "self",(char *) "row", NULL
52617 };
52618
52619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
52620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52621 if (!SWIG_IsOK(res1)) {
52622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52623 }
52624 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52625 ecode2 = SWIG_AsVal_int(obj1, &val2);
52626 if (!SWIG_IsOK(ecode2)) {
52627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
52628 }
52629 arg2 = static_cast< int >(val2);
52630 {
52631 PyThreadState* __tstate = wxPyBeginAllowThreads();
52632 (arg1)->SetRow(arg2);
52633 wxPyEndAllowThreads(__tstate);
52634 if (PyErr_Occurred()) SWIG_fail;
52635 }
52636 resultobj = SWIG_Py_Void();
52637 return resultobj;
52638 fail:
52639 return NULL;
52640 }
52641
52642
52643 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52644 PyObject *resultobj = 0;
52645 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52646 int arg2 ;
52647 void *argp1 = 0 ;
52648 int res1 = 0 ;
52649 int val2 ;
52650 int ecode2 = 0 ;
52651 PyObject * obj0 = 0 ;
52652 PyObject * obj1 = 0 ;
52653 char * kwnames[] = {
52654 (char *) "self",(char *) "col", NULL
52655 };
52656
52657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
52658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52659 if (!SWIG_IsOK(res1)) {
52660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52661 }
52662 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52663 ecode2 = SWIG_AsVal_int(obj1, &val2);
52664 if (!SWIG_IsOK(ecode2)) {
52665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
52666 }
52667 arg2 = static_cast< int >(val2);
52668 {
52669 PyThreadState* __tstate = wxPyBeginAllowThreads();
52670 (arg1)->SetCol(arg2);
52671 wxPyEndAllowThreads(__tstate);
52672 if (PyErr_Occurred()) SWIG_fail;
52673 }
52674 resultobj = SWIG_Py_Void();
52675 return resultobj;
52676 fail:
52677 return NULL;
52678 }
52679
52680
52681 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52682 PyObject *resultobj = 0;
52683 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52684 PyObject *arg2 = (PyObject *) 0 ;
52685 bool result;
52686 void *argp1 = 0 ;
52687 int res1 = 0 ;
52688 PyObject * obj0 = 0 ;
52689 PyObject * obj1 = 0 ;
52690 char * kwnames[] = {
52691 (char *) "self",(char *) "other", NULL
52692 };
52693
52694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
52695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52696 if (!SWIG_IsOK(res1)) {
52697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52698 }
52699 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52700 arg2 = obj1;
52701 {
52702 result = (bool)wxGBPosition___eq__(arg1,arg2);
52703 if (PyErr_Occurred()) SWIG_fail;
52704 }
52705 {
52706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52707 }
52708 return resultobj;
52709 fail:
52710 return NULL;
52711 }
52712
52713
52714 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52715 PyObject *resultobj = 0;
52716 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52717 PyObject *arg2 = (PyObject *) 0 ;
52718 bool result;
52719 void *argp1 = 0 ;
52720 int res1 = 0 ;
52721 PyObject * obj0 = 0 ;
52722 PyObject * obj1 = 0 ;
52723 char * kwnames[] = {
52724 (char *) "self",(char *) "other", NULL
52725 };
52726
52727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
52728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52729 if (!SWIG_IsOK(res1)) {
52730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52731 }
52732 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52733 arg2 = obj1;
52734 {
52735 result = (bool)wxGBPosition___ne__(arg1,arg2);
52736 if (PyErr_Occurred()) SWIG_fail;
52737 }
52738 {
52739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52740 }
52741 return resultobj;
52742 fail:
52743 return NULL;
52744 }
52745
52746
52747 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52748 PyObject *resultobj = 0;
52749 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52750 int arg2 = (int) 0 ;
52751 int arg3 = (int) 0 ;
52752 void *argp1 = 0 ;
52753 int res1 = 0 ;
52754 int val2 ;
52755 int ecode2 = 0 ;
52756 int val3 ;
52757 int ecode3 = 0 ;
52758 PyObject * obj0 = 0 ;
52759 PyObject * obj1 = 0 ;
52760 PyObject * obj2 = 0 ;
52761 char * kwnames[] = {
52762 (char *) "self",(char *) "row",(char *) "col", NULL
52763 };
52764
52765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52767 if (!SWIG_IsOK(res1)) {
52768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52769 }
52770 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52771 if (obj1) {
52772 ecode2 = SWIG_AsVal_int(obj1, &val2);
52773 if (!SWIG_IsOK(ecode2)) {
52774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
52775 }
52776 arg2 = static_cast< int >(val2);
52777 }
52778 if (obj2) {
52779 ecode3 = SWIG_AsVal_int(obj2, &val3);
52780 if (!SWIG_IsOK(ecode3)) {
52781 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
52782 }
52783 arg3 = static_cast< int >(val3);
52784 }
52785 {
52786 PyThreadState* __tstate = wxPyBeginAllowThreads();
52787 wxGBPosition_Set(arg1,arg2,arg3);
52788 wxPyEndAllowThreads(__tstate);
52789 if (PyErr_Occurred()) SWIG_fail;
52790 }
52791 resultobj = SWIG_Py_Void();
52792 return resultobj;
52793 fail:
52794 return NULL;
52795 }
52796
52797
52798 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52799 PyObject *resultobj = 0;
52800 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52801 PyObject *result = 0 ;
52802 void *argp1 = 0 ;
52803 int res1 = 0 ;
52804 PyObject *swig_obj[1] ;
52805
52806 if (!args) SWIG_fail;
52807 swig_obj[0] = args;
52808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52809 if (!SWIG_IsOK(res1)) {
52810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52811 }
52812 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52813 {
52814 PyThreadState* __tstate = wxPyBeginAllowThreads();
52815 result = (PyObject *)wxGBPosition_Get(arg1);
52816 wxPyEndAllowThreads(__tstate);
52817 if (PyErr_Occurred()) SWIG_fail;
52818 }
52819 resultobj = result;
52820 return resultobj;
52821 fail:
52822 return NULL;
52823 }
52824
52825
52826 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52827 PyObject *obj;
52828 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52829 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
52830 return SWIG_Py_Void();
52831 }
52832
52833 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52834 return SWIG_Python_InitShadowInstance(args);
52835 }
52836
52837 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52838 PyObject *resultobj = 0;
52839 int arg1 = (int) 1 ;
52840 int arg2 = (int) 1 ;
52841 wxGBSpan *result = 0 ;
52842 int val1 ;
52843 int ecode1 = 0 ;
52844 int val2 ;
52845 int ecode2 = 0 ;
52846 PyObject * obj0 = 0 ;
52847 PyObject * obj1 = 0 ;
52848 char * kwnames[] = {
52849 (char *) "rowspan",(char *) "colspan", NULL
52850 };
52851
52852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
52853 if (obj0) {
52854 ecode1 = SWIG_AsVal_int(obj0, &val1);
52855 if (!SWIG_IsOK(ecode1)) {
52856 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
52857 }
52858 arg1 = static_cast< int >(val1);
52859 }
52860 if (obj1) {
52861 ecode2 = SWIG_AsVal_int(obj1, &val2);
52862 if (!SWIG_IsOK(ecode2)) {
52863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
52864 }
52865 arg2 = static_cast< int >(val2);
52866 }
52867 {
52868 PyThreadState* __tstate = wxPyBeginAllowThreads();
52869 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
52870 wxPyEndAllowThreads(__tstate);
52871 if (PyErr_Occurred()) SWIG_fail;
52872 }
52873 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
52874 return resultobj;
52875 fail:
52876 return NULL;
52877 }
52878
52879
52880 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52881 PyObject *resultobj = 0;
52882 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52883 void *argp1 = 0 ;
52884 int res1 = 0 ;
52885 PyObject *swig_obj[1] ;
52886
52887 if (!args) SWIG_fail;
52888 swig_obj[0] = args;
52889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
52890 if (!SWIG_IsOK(res1)) {
52891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
52892 }
52893 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
52894 {
52895 PyThreadState* __tstate = wxPyBeginAllowThreads();
52896 delete arg1;
52897
52898 wxPyEndAllowThreads(__tstate);
52899 if (PyErr_Occurred()) SWIG_fail;
52900 }
52901 resultobj = SWIG_Py_Void();
52902 return resultobj;
52903 fail:
52904 return NULL;
52905 }
52906
52907
52908 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52909 PyObject *resultobj = 0;
52910 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52911 int result;
52912 void *argp1 = 0 ;
52913 int res1 = 0 ;
52914 PyObject *swig_obj[1] ;
52915
52916 if (!args) SWIG_fail;
52917 swig_obj[0] = args;
52918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
52919 if (!SWIG_IsOK(res1)) {
52920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
52921 }
52922 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
52923 {
52924 PyThreadState* __tstate = wxPyBeginAllowThreads();
52925 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
52926 wxPyEndAllowThreads(__tstate);
52927 if (PyErr_Occurred()) SWIG_fail;
52928 }
52929 resultobj = SWIG_From_int(static_cast< int >(result));
52930 return resultobj;
52931 fail:
52932 return NULL;
52933 }
52934
52935
52936 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52937 PyObject *resultobj = 0;
52938 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52939 int result;
52940 void *argp1 = 0 ;
52941 int res1 = 0 ;
52942 PyObject *swig_obj[1] ;
52943
52944 if (!args) SWIG_fail;
52945 swig_obj[0] = args;
52946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
52947 if (!SWIG_IsOK(res1)) {
52948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
52949 }
52950 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
52951 {
52952 PyThreadState* __tstate = wxPyBeginAllowThreads();
52953 result = (int)((wxGBSpan const *)arg1)->GetColspan();
52954 wxPyEndAllowThreads(__tstate);
52955 if (PyErr_Occurred()) SWIG_fail;
52956 }
52957 resultobj = SWIG_From_int(static_cast< int >(result));
52958 return resultobj;
52959 fail:
52960 return NULL;
52961 }
52962
52963
52964 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52965 PyObject *resultobj = 0;
52966 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52967 int arg2 ;
52968 void *argp1 = 0 ;
52969 int res1 = 0 ;
52970 int val2 ;
52971 int ecode2 = 0 ;
52972 PyObject * obj0 = 0 ;
52973 PyObject * obj1 = 0 ;
52974 char * kwnames[] = {
52975 (char *) "self",(char *) "rowspan", NULL
52976 };
52977
52978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
52979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
52980 if (!SWIG_IsOK(res1)) {
52981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
52982 }
52983 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
52984 ecode2 = SWIG_AsVal_int(obj1, &val2);
52985 if (!SWIG_IsOK(ecode2)) {
52986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
52987 }
52988 arg2 = static_cast< int >(val2);
52989 {
52990 PyThreadState* __tstate = wxPyBeginAllowThreads();
52991 (arg1)->SetRowspan(arg2);
52992 wxPyEndAllowThreads(__tstate);
52993 if (PyErr_Occurred()) SWIG_fail;
52994 }
52995 resultobj = SWIG_Py_Void();
52996 return resultobj;
52997 fail:
52998 return NULL;
52999 }
53000
53001
53002 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53003 PyObject *resultobj = 0;
53004 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53005 int arg2 ;
53006 void *argp1 = 0 ;
53007 int res1 = 0 ;
53008 int val2 ;
53009 int ecode2 = 0 ;
53010 PyObject * obj0 = 0 ;
53011 PyObject * obj1 = 0 ;
53012 char * kwnames[] = {
53013 (char *) "self",(char *) "colspan", NULL
53014 };
53015
53016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
53017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53018 if (!SWIG_IsOK(res1)) {
53019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53020 }
53021 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53022 ecode2 = SWIG_AsVal_int(obj1, &val2);
53023 if (!SWIG_IsOK(ecode2)) {
53024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
53025 }
53026 arg2 = static_cast< int >(val2);
53027 {
53028 PyThreadState* __tstate = wxPyBeginAllowThreads();
53029 (arg1)->SetColspan(arg2);
53030 wxPyEndAllowThreads(__tstate);
53031 if (PyErr_Occurred()) SWIG_fail;
53032 }
53033 resultobj = SWIG_Py_Void();
53034 return resultobj;
53035 fail:
53036 return NULL;
53037 }
53038
53039
53040 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53041 PyObject *resultobj = 0;
53042 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53043 PyObject *arg2 = (PyObject *) 0 ;
53044 bool result;
53045 void *argp1 = 0 ;
53046 int res1 = 0 ;
53047 PyObject * obj0 = 0 ;
53048 PyObject * obj1 = 0 ;
53049 char * kwnames[] = {
53050 (char *) "self",(char *) "other", NULL
53051 };
53052
53053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
53054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53055 if (!SWIG_IsOK(res1)) {
53056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53057 }
53058 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53059 arg2 = obj1;
53060 {
53061 result = (bool)wxGBSpan___eq__(arg1,arg2);
53062 if (PyErr_Occurred()) SWIG_fail;
53063 }
53064 {
53065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53066 }
53067 return resultobj;
53068 fail:
53069 return NULL;
53070 }
53071
53072
53073 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53074 PyObject *resultobj = 0;
53075 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53076 PyObject *arg2 = (PyObject *) 0 ;
53077 bool result;
53078 void *argp1 = 0 ;
53079 int res1 = 0 ;
53080 PyObject * obj0 = 0 ;
53081 PyObject * obj1 = 0 ;
53082 char * kwnames[] = {
53083 (char *) "self",(char *) "other", NULL
53084 };
53085
53086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
53087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53088 if (!SWIG_IsOK(res1)) {
53089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53090 }
53091 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53092 arg2 = obj1;
53093 {
53094 result = (bool)wxGBSpan___ne__(arg1,arg2);
53095 if (PyErr_Occurred()) SWIG_fail;
53096 }
53097 {
53098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53099 }
53100 return resultobj;
53101 fail:
53102 return NULL;
53103 }
53104
53105
53106 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53107 PyObject *resultobj = 0;
53108 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53109 int arg2 = (int) 1 ;
53110 int arg3 = (int) 1 ;
53111 void *argp1 = 0 ;
53112 int res1 = 0 ;
53113 int val2 ;
53114 int ecode2 = 0 ;
53115 int val3 ;
53116 int ecode3 = 0 ;
53117 PyObject * obj0 = 0 ;
53118 PyObject * obj1 = 0 ;
53119 PyObject * obj2 = 0 ;
53120 char * kwnames[] = {
53121 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
53122 };
53123
53124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53126 if (!SWIG_IsOK(res1)) {
53127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53128 }
53129 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53130 if (obj1) {
53131 ecode2 = SWIG_AsVal_int(obj1, &val2);
53132 if (!SWIG_IsOK(ecode2)) {
53133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
53134 }
53135 arg2 = static_cast< int >(val2);
53136 }
53137 if (obj2) {
53138 ecode3 = SWIG_AsVal_int(obj2, &val3);
53139 if (!SWIG_IsOK(ecode3)) {
53140 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
53141 }
53142 arg3 = static_cast< int >(val3);
53143 }
53144 {
53145 PyThreadState* __tstate = wxPyBeginAllowThreads();
53146 wxGBSpan_Set(arg1,arg2,arg3);
53147 wxPyEndAllowThreads(__tstate);
53148 if (PyErr_Occurred()) SWIG_fail;
53149 }
53150 resultobj = SWIG_Py_Void();
53151 return resultobj;
53152 fail:
53153 return NULL;
53154 }
53155
53156
53157 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53158 PyObject *resultobj = 0;
53159 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53160 PyObject *result = 0 ;
53161 void *argp1 = 0 ;
53162 int res1 = 0 ;
53163 PyObject *swig_obj[1] ;
53164
53165 if (!args) SWIG_fail;
53166 swig_obj[0] = args;
53167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53168 if (!SWIG_IsOK(res1)) {
53169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53170 }
53171 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53172 {
53173 PyThreadState* __tstate = wxPyBeginAllowThreads();
53174 result = (PyObject *)wxGBSpan_Get(arg1);
53175 wxPyEndAllowThreads(__tstate);
53176 if (PyErr_Occurred()) SWIG_fail;
53177 }
53178 resultobj = result;
53179 return resultobj;
53180 fail:
53181 return NULL;
53182 }
53183
53184
53185 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53186 PyObject *obj;
53187 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53188 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
53189 return SWIG_Py_Void();
53190 }
53191
53192 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53193 return SWIG_Python_InitShadowInstance(args);
53194 }
53195
53196 SWIGINTERN int DefaultSpan_set(PyObject *) {
53197 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
53198 return 1;
53199 }
53200
53201
53202 SWIGINTERN PyObject *DefaultSpan_get(void) {
53203 PyObject *pyobj = 0;
53204
53205 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
53206 return pyobj;
53207 }
53208
53209
53210 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53211 PyObject *resultobj = 0;
53212 wxGBSizerItem *result = 0 ;
53213
53214 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
53215 {
53216 PyThreadState* __tstate = wxPyBeginAllowThreads();
53217 result = (wxGBSizerItem *)new wxGBSizerItem();
53218 wxPyEndAllowThreads(__tstate);
53219 if (PyErr_Occurred()) SWIG_fail;
53220 }
53221 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
53222 return resultobj;
53223 fail:
53224 return NULL;
53225 }
53226
53227
53228 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53229 PyObject *resultobj = 0;
53230 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53231 void *argp1 = 0 ;
53232 int res1 = 0 ;
53233 PyObject *swig_obj[1] ;
53234
53235 if (!args) SWIG_fail;
53236 swig_obj[0] = args;
53237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
53238 if (!SWIG_IsOK(res1)) {
53239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53240 }
53241 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53242 {
53243 PyThreadState* __tstate = wxPyBeginAllowThreads();
53244 delete arg1;
53245
53246 wxPyEndAllowThreads(__tstate);
53247 if (PyErr_Occurred()) SWIG_fail;
53248 }
53249 resultobj = SWIG_Py_Void();
53250 return resultobj;
53251 fail:
53252 return NULL;
53253 }
53254
53255
53256 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53257 PyObject *resultobj = 0;
53258 wxWindow *arg1 = (wxWindow *) 0 ;
53259 wxGBPosition *arg2 = 0 ;
53260 wxGBSpan *arg3 = 0 ;
53261 int arg4 ;
53262 int arg5 ;
53263 PyObject *arg6 = (PyObject *) NULL ;
53264 wxGBSizerItem *result = 0 ;
53265 void *argp1 = 0 ;
53266 int res1 = 0 ;
53267 wxGBPosition temp2 ;
53268 wxGBSpan temp3 ;
53269 int val4 ;
53270 int ecode4 = 0 ;
53271 int val5 ;
53272 int ecode5 = 0 ;
53273 PyObject * obj0 = 0 ;
53274 PyObject * obj1 = 0 ;
53275 PyObject * obj2 = 0 ;
53276 PyObject * obj3 = 0 ;
53277 PyObject * obj4 = 0 ;
53278 PyObject * obj5 = 0 ;
53279 char * kwnames[] = {
53280 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53281 };
53282
53283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
53285 if (!SWIG_IsOK(res1)) {
53286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
53287 }
53288 arg1 = reinterpret_cast< wxWindow * >(argp1);
53289 {
53290 arg2 = &temp2;
53291 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53292 }
53293 {
53294 arg3 = &temp3;
53295 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53296 }
53297 ecode4 = SWIG_AsVal_int(obj3, &val4);
53298 if (!SWIG_IsOK(ecode4)) {
53299 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
53300 }
53301 arg4 = static_cast< int >(val4);
53302 ecode5 = SWIG_AsVal_int(obj4, &val5);
53303 if (!SWIG_IsOK(ecode5)) {
53304 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
53305 }
53306 arg5 = static_cast< int >(val5);
53307 if (obj5) {
53308 arg6 = obj5;
53309 }
53310 {
53311 PyThreadState* __tstate = wxPyBeginAllowThreads();
53312 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53313 wxPyEndAllowThreads(__tstate);
53314 if (PyErr_Occurred()) SWIG_fail;
53315 }
53316 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53317 return resultobj;
53318 fail:
53319 return NULL;
53320 }
53321
53322
53323 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53324 PyObject *resultobj = 0;
53325 wxSizer *arg1 = (wxSizer *) 0 ;
53326 wxGBPosition *arg2 = 0 ;
53327 wxGBSpan *arg3 = 0 ;
53328 int arg4 ;
53329 int arg5 ;
53330 PyObject *arg6 = (PyObject *) NULL ;
53331 wxGBSizerItem *result = 0 ;
53332 int res1 = 0 ;
53333 wxGBPosition temp2 ;
53334 wxGBSpan temp3 ;
53335 int val4 ;
53336 int ecode4 = 0 ;
53337 int val5 ;
53338 int ecode5 = 0 ;
53339 PyObject * obj0 = 0 ;
53340 PyObject * obj1 = 0 ;
53341 PyObject * obj2 = 0 ;
53342 PyObject * obj3 = 0 ;
53343 PyObject * obj4 = 0 ;
53344 PyObject * obj5 = 0 ;
53345 char * kwnames[] = {
53346 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53347 };
53348
53349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53350 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
53351 if (!SWIG_IsOK(res1)) {
53352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
53353 }
53354 {
53355 arg2 = &temp2;
53356 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53357 }
53358 {
53359 arg3 = &temp3;
53360 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53361 }
53362 ecode4 = SWIG_AsVal_int(obj3, &val4);
53363 if (!SWIG_IsOK(ecode4)) {
53364 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
53365 }
53366 arg4 = static_cast< int >(val4);
53367 ecode5 = SWIG_AsVal_int(obj4, &val5);
53368 if (!SWIG_IsOK(ecode5)) {
53369 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
53370 }
53371 arg5 = static_cast< int >(val5);
53372 if (obj5) {
53373 arg6 = obj5;
53374 }
53375 {
53376 PyThreadState* __tstate = wxPyBeginAllowThreads();
53377 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53378 wxPyEndAllowThreads(__tstate);
53379 if (PyErr_Occurred()) SWIG_fail;
53380 }
53381 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53382 return resultobj;
53383 fail:
53384 return NULL;
53385 }
53386
53387
53388 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53389 PyObject *resultobj = 0;
53390 int arg1 ;
53391 int arg2 ;
53392 wxGBPosition *arg3 = 0 ;
53393 wxGBSpan *arg4 = 0 ;
53394 int arg5 ;
53395 int arg6 ;
53396 PyObject *arg7 = (PyObject *) NULL ;
53397 wxGBSizerItem *result = 0 ;
53398 int val1 ;
53399 int ecode1 = 0 ;
53400 int val2 ;
53401 int ecode2 = 0 ;
53402 wxGBPosition temp3 ;
53403 wxGBSpan temp4 ;
53404 int val5 ;
53405 int ecode5 = 0 ;
53406 int val6 ;
53407 int ecode6 = 0 ;
53408 PyObject * obj0 = 0 ;
53409 PyObject * obj1 = 0 ;
53410 PyObject * obj2 = 0 ;
53411 PyObject * obj3 = 0 ;
53412 PyObject * obj4 = 0 ;
53413 PyObject * obj5 = 0 ;
53414 PyObject * obj6 = 0 ;
53415 char * kwnames[] = {
53416 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53417 };
53418
53419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53420 ecode1 = SWIG_AsVal_int(obj0, &val1);
53421 if (!SWIG_IsOK(ecode1)) {
53422 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
53423 }
53424 arg1 = static_cast< int >(val1);
53425 ecode2 = SWIG_AsVal_int(obj1, &val2);
53426 if (!SWIG_IsOK(ecode2)) {
53427 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
53428 }
53429 arg2 = static_cast< int >(val2);
53430 {
53431 arg3 = &temp3;
53432 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53433 }
53434 {
53435 arg4 = &temp4;
53436 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
53437 }
53438 ecode5 = SWIG_AsVal_int(obj4, &val5);
53439 if (!SWIG_IsOK(ecode5)) {
53440 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
53441 }
53442 arg5 = static_cast< int >(val5);
53443 ecode6 = SWIG_AsVal_int(obj5, &val6);
53444 if (!SWIG_IsOK(ecode6)) {
53445 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
53446 }
53447 arg6 = static_cast< int >(val6);
53448 if (obj6) {
53449 arg7 = obj6;
53450 }
53451 {
53452 PyThreadState* __tstate = wxPyBeginAllowThreads();
53453 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
53454 wxPyEndAllowThreads(__tstate);
53455 if (PyErr_Occurred()) SWIG_fail;
53456 }
53457 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53458 return resultobj;
53459 fail:
53460 return NULL;
53461 }
53462
53463
53464 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53465 PyObject *resultobj = 0;
53466 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53467 wxGBPosition result;
53468 void *argp1 = 0 ;
53469 int res1 = 0 ;
53470 PyObject *swig_obj[1] ;
53471
53472 if (!args) SWIG_fail;
53473 swig_obj[0] = args;
53474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53475 if (!SWIG_IsOK(res1)) {
53476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53477 }
53478 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53479 {
53480 PyThreadState* __tstate = wxPyBeginAllowThreads();
53481 result = ((wxGBSizerItem const *)arg1)->GetPos();
53482 wxPyEndAllowThreads(__tstate);
53483 if (PyErr_Occurred()) SWIG_fail;
53484 }
53485 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53486 return resultobj;
53487 fail:
53488 return NULL;
53489 }
53490
53491
53492 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53493 PyObject *resultobj = 0;
53494 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53495 wxGBSpan result;
53496 void *argp1 = 0 ;
53497 int res1 = 0 ;
53498 PyObject *swig_obj[1] ;
53499
53500 if (!args) SWIG_fail;
53501 swig_obj[0] = args;
53502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53503 if (!SWIG_IsOK(res1)) {
53504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53505 }
53506 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53507 {
53508 PyThreadState* __tstate = wxPyBeginAllowThreads();
53509 result = ((wxGBSizerItem const *)arg1)->GetSpan();
53510 wxPyEndAllowThreads(__tstate);
53511 if (PyErr_Occurred()) SWIG_fail;
53512 }
53513 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
53514 return resultobj;
53515 fail:
53516 return NULL;
53517 }
53518
53519
53520 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53521 PyObject *resultobj = 0;
53522 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53523 wxGBPosition *arg2 = 0 ;
53524 bool result;
53525 void *argp1 = 0 ;
53526 int res1 = 0 ;
53527 wxGBPosition temp2 ;
53528 PyObject * obj0 = 0 ;
53529 PyObject * obj1 = 0 ;
53530 char * kwnames[] = {
53531 (char *) "self",(char *) "pos", NULL
53532 };
53533
53534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
53535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53536 if (!SWIG_IsOK(res1)) {
53537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53538 }
53539 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53540 {
53541 arg2 = &temp2;
53542 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53543 }
53544 {
53545 PyThreadState* __tstate = wxPyBeginAllowThreads();
53546 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
53547 wxPyEndAllowThreads(__tstate);
53548 if (PyErr_Occurred()) SWIG_fail;
53549 }
53550 {
53551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53552 }
53553 return resultobj;
53554 fail:
53555 return NULL;
53556 }
53557
53558
53559 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53560 PyObject *resultobj = 0;
53561 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53562 wxGBSpan *arg2 = 0 ;
53563 bool result;
53564 void *argp1 = 0 ;
53565 int res1 = 0 ;
53566 wxGBSpan temp2 ;
53567 PyObject * obj0 = 0 ;
53568 PyObject * obj1 = 0 ;
53569 char * kwnames[] = {
53570 (char *) "self",(char *) "span", NULL
53571 };
53572
53573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
53574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53575 if (!SWIG_IsOK(res1)) {
53576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53577 }
53578 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53579 {
53580 arg2 = &temp2;
53581 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
53582 }
53583 {
53584 PyThreadState* __tstate = wxPyBeginAllowThreads();
53585 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
53586 wxPyEndAllowThreads(__tstate);
53587 if (PyErr_Occurred()) SWIG_fail;
53588 }
53589 {
53590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53591 }
53592 return resultobj;
53593 fail:
53594 return NULL;
53595 }
53596
53597
53598 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53599 PyObject *resultobj = 0;
53600 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53601 wxGBSizerItem *arg2 = 0 ;
53602 bool result;
53603 void *argp1 = 0 ;
53604 int res1 = 0 ;
53605 void *argp2 = 0 ;
53606 int res2 = 0 ;
53607 PyObject * obj0 = 0 ;
53608 PyObject * obj1 = 0 ;
53609 char * kwnames[] = {
53610 (char *) "self",(char *) "other", NULL
53611 };
53612
53613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
53614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53615 if (!SWIG_IsOK(res1)) {
53616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53617 }
53618 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53619 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
53620 if (!SWIG_IsOK(res2)) {
53621 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53622 }
53623 if (!argp2) {
53624 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53625 }
53626 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
53627 {
53628 PyThreadState* __tstate = wxPyBeginAllowThreads();
53629 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
53630 wxPyEndAllowThreads(__tstate);
53631 if (PyErr_Occurred()) SWIG_fail;
53632 }
53633 {
53634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53635 }
53636 return resultobj;
53637 fail:
53638 return NULL;
53639 }
53640
53641
53642 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53643 PyObject *resultobj = 0;
53644 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53645 wxGBPosition *arg2 = 0 ;
53646 wxGBSpan *arg3 = 0 ;
53647 bool result;
53648 void *argp1 = 0 ;
53649 int res1 = 0 ;
53650 wxGBPosition temp2 ;
53651 wxGBSpan temp3 ;
53652 PyObject * obj0 = 0 ;
53653 PyObject * obj1 = 0 ;
53654 PyObject * obj2 = 0 ;
53655 char * kwnames[] = {
53656 (char *) "self",(char *) "pos",(char *) "span", NULL
53657 };
53658
53659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53661 if (!SWIG_IsOK(res1)) {
53662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53663 }
53664 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53665 {
53666 arg2 = &temp2;
53667 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53668 }
53669 {
53670 arg3 = &temp3;
53671 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53672 }
53673 {
53674 PyThreadState* __tstate = wxPyBeginAllowThreads();
53675 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
53676 wxPyEndAllowThreads(__tstate);
53677 if (PyErr_Occurred()) SWIG_fail;
53678 }
53679 {
53680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53681 }
53682 return resultobj;
53683 fail:
53684 return NULL;
53685 }
53686
53687
53688 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53689 PyObject *resultobj = 0;
53690 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53691 wxGBPosition result;
53692 void *argp1 = 0 ;
53693 int res1 = 0 ;
53694 PyObject *swig_obj[1] ;
53695
53696 if (!args) SWIG_fail;
53697 swig_obj[0] = args;
53698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53699 if (!SWIG_IsOK(res1)) {
53700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53701 }
53702 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53703 {
53704 PyThreadState* __tstate = wxPyBeginAllowThreads();
53705 result = wxGBSizerItem_GetEndPos(arg1);
53706 wxPyEndAllowThreads(__tstate);
53707 if (PyErr_Occurred()) SWIG_fail;
53708 }
53709 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53710 return resultobj;
53711 fail:
53712 return NULL;
53713 }
53714
53715
53716 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53717 PyObject *resultobj = 0;
53718 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53719 wxGridBagSizer *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_wxGBSizerItem, 0 | 0 );
53727 if (!SWIG_IsOK(res1)) {
53728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53729 }
53730 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53731 {
53732 PyThreadState* __tstate = wxPyBeginAllowThreads();
53733 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
53734 wxPyEndAllowThreads(__tstate);
53735 if (PyErr_Occurred()) SWIG_fail;
53736 }
53737 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53738 return resultobj;
53739 fail:
53740 return NULL;
53741 }
53742
53743
53744 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53745 PyObject *resultobj = 0;
53746 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53747 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
53748 void *argp1 = 0 ;
53749 int res1 = 0 ;
53750 void *argp2 = 0 ;
53751 int res2 = 0 ;
53752 PyObject * obj0 = 0 ;
53753 PyObject * obj1 = 0 ;
53754 char * kwnames[] = {
53755 (char *) "self",(char *) "sizer", NULL
53756 };
53757
53758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53760 if (!SWIG_IsOK(res1)) {
53761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53762 }
53763 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53764 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53765 if (!SWIG_IsOK(res2)) {
53766 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
53767 }
53768 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
53769 {
53770 PyThreadState* __tstate = wxPyBeginAllowThreads();
53771 (arg1)->SetGBSizer(arg2);
53772 wxPyEndAllowThreads(__tstate);
53773 if (PyErr_Occurred()) SWIG_fail;
53774 }
53775 resultobj = SWIG_Py_Void();
53776 return resultobj;
53777 fail:
53778 return NULL;
53779 }
53780
53781
53782 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53783 PyObject *obj;
53784 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53785 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
53786 return SWIG_Py_Void();
53787 }
53788
53789 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53790 return SWIG_Python_InitShadowInstance(args);
53791 }
53792
53793 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53794 PyObject *resultobj = 0;
53795 int arg1 = (int) 0 ;
53796 int arg2 = (int) 0 ;
53797 wxGridBagSizer *result = 0 ;
53798 int val1 ;
53799 int ecode1 = 0 ;
53800 int val2 ;
53801 int ecode2 = 0 ;
53802 PyObject * obj0 = 0 ;
53803 PyObject * obj1 = 0 ;
53804 char * kwnames[] = {
53805 (char *) "vgap",(char *) "hgap", NULL
53806 };
53807
53808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53809 if (obj0) {
53810 ecode1 = SWIG_AsVal_int(obj0, &val1);
53811 if (!SWIG_IsOK(ecode1)) {
53812 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
53813 }
53814 arg1 = static_cast< int >(val1);
53815 }
53816 if (obj1) {
53817 ecode2 = SWIG_AsVal_int(obj1, &val2);
53818 if (!SWIG_IsOK(ecode2)) {
53819 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
53820 }
53821 arg2 = static_cast< int >(val2);
53822 }
53823 {
53824 PyThreadState* __tstate = wxPyBeginAllowThreads();
53825 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
53826 wxPyEndAllowThreads(__tstate);
53827 if (PyErr_Occurred()) SWIG_fail;
53828 }
53829 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
53830 return resultobj;
53831 fail:
53832 return NULL;
53833 }
53834
53835
53836 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53837 PyObject *resultobj = 0;
53838 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53839 PyObject *arg2 = (PyObject *) 0 ;
53840 wxGBPosition *arg3 = 0 ;
53841 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
53842 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
53843 int arg5 = (int) 0 ;
53844 int arg6 = (int) 0 ;
53845 PyObject *arg7 = (PyObject *) NULL ;
53846 wxGBSizerItem *result = 0 ;
53847 void *argp1 = 0 ;
53848 int res1 = 0 ;
53849 wxGBPosition temp3 ;
53850 wxGBSpan temp4 ;
53851 int val5 ;
53852 int ecode5 = 0 ;
53853 int val6 ;
53854 int ecode6 = 0 ;
53855 PyObject * obj0 = 0 ;
53856 PyObject * obj1 = 0 ;
53857 PyObject * obj2 = 0 ;
53858 PyObject * obj3 = 0 ;
53859 PyObject * obj4 = 0 ;
53860 PyObject * obj5 = 0 ;
53861 PyObject * obj6 = 0 ;
53862 char * kwnames[] = {
53863 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53864 };
53865
53866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53868 if (!SWIG_IsOK(res1)) {
53869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
53870 }
53871 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
53872 arg2 = obj1;
53873 {
53874 arg3 = &temp3;
53875 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53876 }
53877 if (obj3) {
53878 {
53879 arg4 = &temp4;
53880 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
53881 }
53882 }
53883 if (obj4) {
53884 ecode5 = SWIG_AsVal_int(obj4, &val5);
53885 if (!SWIG_IsOK(ecode5)) {
53886 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
53887 }
53888 arg5 = static_cast< int >(val5);
53889 }
53890 if (obj5) {
53891 ecode6 = SWIG_AsVal_int(obj5, &val6);
53892 if (!SWIG_IsOK(ecode6)) {
53893 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
53894 }
53895 arg6 = static_cast< int >(val6);
53896 }
53897 if (obj6) {
53898 arg7 = obj6;
53899 }
53900 {
53901 PyThreadState* __tstate = wxPyBeginAllowThreads();
53902 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
53903 wxPyEndAllowThreads(__tstate);
53904 if (PyErr_Occurred()) SWIG_fail;
53905 }
53906 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53907 return resultobj;
53908 fail:
53909 return NULL;
53910 }
53911
53912
53913 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53914 PyObject *resultobj = 0;
53915 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53916 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
53917 wxGBSizerItem *result = 0 ;
53918 void *argp1 = 0 ;
53919 int res1 = 0 ;
53920 int res2 = 0 ;
53921 PyObject * obj0 = 0 ;
53922 PyObject * obj1 = 0 ;
53923 char * kwnames[] = {
53924 (char *) "self",(char *) "item", NULL
53925 };
53926
53927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
53928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53929 if (!SWIG_IsOK(res1)) {
53930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
53931 }
53932 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
53933 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
53934 if (!SWIG_IsOK(res2)) {
53935 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
53936 }
53937 {
53938 PyThreadState* __tstate = wxPyBeginAllowThreads();
53939 result = (wxGBSizerItem *)(arg1)->Add(arg2);
53940 wxPyEndAllowThreads(__tstate);
53941 if (PyErr_Occurred()) SWIG_fail;
53942 }
53943 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53944 return resultobj;
53945 fail:
53946 return NULL;
53947 }
53948
53949
53950 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53951 PyObject *resultobj = 0;
53952 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53953 int arg2 ;
53954 int arg3 ;
53955 wxSize result;
53956 void *argp1 = 0 ;
53957 int res1 = 0 ;
53958 int val2 ;
53959 int ecode2 = 0 ;
53960 int val3 ;
53961 int ecode3 = 0 ;
53962 PyObject * obj0 = 0 ;
53963 PyObject * obj1 = 0 ;
53964 PyObject * obj2 = 0 ;
53965 char * kwnames[] = {
53966 (char *) "self",(char *) "row",(char *) "col", NULL
53967 };
53968
53969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53971 if (!SWIG_IsOK(res1)) {
53972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
53973 }
53974 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
53975 ecode2 = SWIG_AsVal_int(obj1, &val2);
53976 if (!SWIG_IsOK(ecode2)) {
53977 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
53978 }
53979 arg2 = static_cast< int >(val2);
53980 ecode3 = SWIG_AsVal_int(obj2, &val3);
53981 if (!SWIG_IsOK(ecode3)) {
53982 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
53983 }
53984 arg3 = static_cast< int >(val3);
53985 {
53986 PyThreadState* __tstate = wxPyBeginAllowThreads();
53987 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
53988 wxPyEndAllowThreads(__tstate);
53989 if (PyErr_Occurred()) SWIG_fail;
53990 }
53991 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
53992 return resultobj;
53993 fail:
53994 return NULL;
53995 }
53996
53997
53998 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53999 PyObject *resultobj = 0;
54000 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54001 wxSize result;
54002 void *argp1 = 0 ;
54003 int res1 = 0 ;
54004 PyObject *swig_obj[1] ;
54005
54006 if (!args) SWIG_fail;
54007 swig_obj[0] = args;
54008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54009 if (!SWIG_IsOK(res1)) {
54010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
54011 }
54012 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54013 {
54014 PyThreadState* __tstate = wxPyBeginAllowThreads();
54015 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
54016 wxPyEndAllowThreads(__tstate);
54017 if (PyErr_Occurred()) SWIG_fail;
54018 }
54019 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54020 return resultobj;
54021 fail:
54022 return NULL;
54023 }
54024
54025
54026 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54027 PyObject *resultobj = 0;
54028 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54029 wxSize *arg2 = 0 ;
54030 void *argp1 = 0 ;
54031 int res1 = 0 ;
54032 wxSize temp2 ;
54033 PyObject * obj0 = 0 ;
54034 PyObject * obj1 = 0 ;
54035 char * kwnames[] = {
54036 (char *) "self",(char *) "sz", NULL
54037 };
54038
54039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
54040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54041 if (!SWIG_IsOK(res1)) {
54042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54043 }
54044 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54045 {
54046 arg2 = &temp2;
54047 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
54048 }
54049 {
54050 PyThreadState* __tstate = wxPyBeginAllowThreads();
54051 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
54052 wxPyEndAllowThreads(__tstate);
54053 if (PyErr_Occurred()) SWIG_fail;
54054 }
54055 resultobj = SWIG_Py_Void();
54056 return resultobj;
54057 fail:
54058 return NULL;
54059 }
54060
54061
54062 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54063 PyObject *resultobj = 0;
54064 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54065 wxWindow *arg2 = (wxWindow *) 0 ;
54066 wxGBPosition result;
54067 void *argp1 = 0 ;
54068 int res1 = 0 ;
54069 void *argp2 = 0 ;
54070 int res2 = 0 ;
54071
54072 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54074 if (!SWIG_IsOK(res1)) {
54075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54076 }
54077 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54078 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54079 if (!SWIG_IsOK(res2)) {
54080 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54081 }
54082 arg2 = reinterpret_cast< wxWindow * >(argp2);
54083 {
54084 PyThreadState* __tstate = wxPyBeginAllowThreads();
54085 result = (arg1)->GetItemPosition(arg2);
54086 wxPyEndAllowThreads(__tstate);
54087 if (PyErr_Occurred()) SWIG_fail;
54088 }
54089 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54090 return resultobj;
54091 fail:
54092 return NULL;
54093 }
54094
54095
54096 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54097 PyObject *resultobj = 0;
54098 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54099 wxSizer *arg2 = (wxSizer *) 0 ;
54100 wxGBPosition result;
54101 void *argp1 = 0 ;
54102 int res1 = 0 ;
54103 void *argp2 = 0 ;
54104 int res2 = 0 ;
54105
54106 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54108 if (!SWIG_IsOK(res1)) {
54109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54110 }
54111 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54112 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54113 if (!SWIG_IsOK(res2)) {
54114 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54115 }
54116 arg2 = reinterpret_cast< wxSizer * >(argp2);
54117 {
54118 PyThreadState* __tstate = wxPyBeginAllowThreads();
54119 result = (arg1)->GetItemPosition(arg2);
54120 wxPyEndAllowThreads(__tstate);
54121 if (PyErr_Occurred()) SWIG_fail;
54122 }
54123 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54124 return resultobj;
54125 fail:
54126 return NULL;
54127 }
54128
54129
54130 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54131 PyObject *resultobj = 0;
54132 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54133 size_t arg2 ;
54134 wxGBPosition result;
54135 void *argp1 = 0 ;
54136 int res1 = 0 ;
54137 size_t val2 ;
54138 int ecode2 = 0 ;
54139
54140 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54142 if (!SWIG_IsOK(res1)) {
54143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54144 }
54145 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54146 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54147 if (!SWIG_IsOK(ecode2)) {
54148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54149 }
54150 arg2 = static_cast< size_t >(val2);
54151 {
54152 PyThreadState* __tstate = wxPyBeginAllowThreads();
54153 result = (arg1)->GetItemPosition(arg2);
54154 wxPyEndAllowThreads(__tstate);
54155 if (PyErr_Occurred()) SWIG_fail;
54156 }
54157 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54158 return resultobj;
54159 fail:
54160 return NULL;
54161 }
54162
54163
54164 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
54165 int argc;
54166 PyObject *argv[3];
54167
54168 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
54169 --argc;
54170 if (argc == 2) {
54171 int _v = 0;
54172 {
54173 void *vptr = 0;
54174 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54175 _v = SWIG_CheckState(res);
54176 }
54177 if (!_v) goto check_1;
54178 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
54179 }
54180 check_1:
54181
54182 if (argc == 2) {
54183 int _v = 0;
54184 {
54185 void *vptr = 0;
54186 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54187 _v = SWIG_CheckState(res);
54188 }
54189 if (!_v) goto check_2;
54190 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
54191 }
54192 check_2:
54193
54194 if (argc == 2) {
54195 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
54196 }
54197
54198 fail:
54199 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
54200 return NULL;
54201 }
54202
54203
54204 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54205 PyObject *resultobj = 0;
54206 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54207 wxWindow *arg2 = (wxWindow *) 0 ;
54208 wxGBPosition *arg3 = 0 ;
54209 bool result;
54210 void *argp1 = 0 ;
54211 int res1 = 0 ;
54212 void *argp2 = 0 ;
54213 int res2 = 0 ;
54214 wxGBPosition temp3 ;
54215
54216 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54218 if (!SWIG_IsOK(res1)) {
54219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54220 }
54221 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54222 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54223 if (!SWIG_IsOK(res2)) {
54224 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54225 }
54226 arg2 = reinterpret_cast< wxWindow * >(argp2);
54227 {
54228 arg3 = &temp3;
54229 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54230 }
54231 {
54232 PyThreadState* __tstate = wxPyBeginAllowThreads();
54233 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54234 wxPyEndAllowThreads(__tstate);
54235 if (PyErr_Occurred()) SWIG_fail;
54236 }
54237 {
54238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54239 }
54240 return resultobj;
54241 fail:
54242 return NULL;
54243 }
54244
54245
54246 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54247 PyObject *resultobj = 0;
54248 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54249 wxSizer *arg2 = (wxSizer *) 0 ;
54250 wxGBPosition *arg3 = 0 ;
54251 bool result;
54252 void *argp1 = 0 ;
54253 int res1 = 0 ;
54254 void *argp2 = 0 ;
54255 int res2 = 0 ;
54256 wxGBPosition temp3 ;
54257
54258 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54260 if (!SWIG_IsOK(res1)) {
54261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54262 }
54263 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54264 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54265 if (!SWIG_IsOK(res2)) {
54266 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54267 }
54268 arg2 = reinterpret_cast< wxSizer * >(argp2);
54269 {
54270 arg3 = &temp3;
54271 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54272 }
54273 {
54274 PyThreadState* __tstate = wxPyBeginAllowThreads();
54275 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54276 wxPyEndAllowThreads(__tstate);
54277 if (PyErr_Occurred()) SWIG_fail;
54278 }
54279 {
54280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54281 }
54282 return resultobj;
54283 fail:
54284 return NULL;
54285 }
54286
54287
54288 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54289 PyObject *resultobj = 0;
54290 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54291 size_t arg2 ;
54292 wxGBPosition *arg3 = 0 ;
54293 bool result;
54294 void *argp1 = 0 ;
54295 int res1 = 0 ;
54296 size_t val2 ;
54297 int ecode2 = 0 ;
54298 wxGBPosition temp3 ;
54299
54300 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54302 if (!SWIG_IsOK(res1)) {
54303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54304 }
54305 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54306 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54307 if (!SWIG_IsOK(ecode2)) {
54308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54309 }
54310 arg2 = static_cast< size_t >(val2);
54311 {
54312 arg3 = &temp3;
54313 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54314 }
54315 {
54316 PyThreadState* __tstate = wxPyBeginAllowThreads();
54317 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54318 wxPyEndAllowThreads(__tstate);
54319 if (PyErr_Occurred()) SWIG_fail;
54320 }
54321 {
54322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54323 }
54324 return resultobj;
54325 fail:
54326 return NULL;
54327 }
54328
54329
54330 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
54331 int argc;
54332 PyObject *argv[4];
54333
54334 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
54335 --argc;
54336 if (argc == 3) {
54337 int _v = 0;
54338 {
54339 void *vptr = 0;
54340 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54341 _v = SWIG_CheckState(res);
54342 }
54343 if (!_v) goto check_1;
54344 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
54345 }
54346 check_1:
54347
54348 if (argc == 3) {
54349 int _v = 0;
54350 {
54351 void *vptr = 0;
54352 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54353 _v = SWIG_CheckState(res);
54354 }
54355 if (!_v) goto check_2;
54356 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
54357 }
54358 check_2:
54359
54360 if (argc == 3) {
54361 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
54362 }
54363
54364 fail:
54365 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
54366 return NULL;
54367 }
54368
54369
54370 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54371 PyObject *resultobj = 0;
54372 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54373 wxWindow *arg2 = (wxWindow *) 0 ;
54374 wxGBSpan result;
54375 void *argp1 = 0 ;
54376 int res1 = 0 ;
54377 void *argp2 = 0 ;
54378 int res2 = 0 ;
54379
54380 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54382 if (!SWIG_IsOK(res1)) {
54383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54384 }
54385 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54386 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54387 if (!SWIG_IsOK(res2)) {
54388 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54389 }
54390 arg2 = reinterpret_cast< wxWindow * >(argp2);
54391 {
54392 PyThreadState* __tstate = wxPyBeginAllowThreads();
54393 result = (arg1)->GetItemSpan(arg2);
54394 wxPyEndAllowThreads(__tstate);
54395 if (PyErr_Occurred()) SWIG_fail;
54396 }
54397 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54398 return resultobj;
54399 fail:
54400 return NULL;
54401 }
54402
54403
54404 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54405 PyObject *resultobj = 0;
54406 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54407 wxSizer *arg2 = (wxSizer *) 0 ;
54408 wxGBSpan result;
54409 void *argp1 = 0 ;
54410 int res1 = 0 ;
54411 void *argp2 = 0 ;
54412 int res2 = 0 ;
54413
54414 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54416 if (!SWIG_IsOK(res1)) {
54417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54418 }
54419 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54420 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54421 if (!SWIG_IsOK(res2)) {
54422 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54423 }
54424 arg2 = reinterpret_cast< wxSizer * >(argp2);
54425 {
54426 PyThreadState* __tstate = wxPyBeginAllowThreads();
54427 result = (arg1)->GetItemSpan(arg2);
54428 wxPyEndAllowThreads(__tstate);
54429 if (PyErr_Occurred()) SWIG_fail;
54430 }
54431 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54432 return resultobj;
54433 fail:
54434 return NULL;
54435 }
54436
54437
54438 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54439 PyObject *resultobj = 0;
54440 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54441 size_t arg2 ;
54442 wxGBSpan result;
54443 void *argp1 = 0 ;
54444 int res1 = 0 ;
54445 size_t val2 ;
54446 int ecode2 = 0 ;
54447
54448 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54450 if (!SWIG_IsOK(res1)) {
54451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54452 }
54453 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54454 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54455 if (!SWIG_IsOK(ecode2)) {
54456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54457 }
54458 arg2 = static_cast< size_t >(val2);
54459 {
54460 PyThreadState* __tstate = wxPyBeginAllowThreads();
54461 result = (arg1)->GetItemSpan(arg2);
54462 wxPyEndAllowThreads(__tstate);
54463 if (PyErr_Occurred()) SWIG_fail;
54464 }
54465 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54466 return resultobj;
54467 fail:
54468 return NULL;
54469 }
54470
54471
54472 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
54473 int argc;
54474 PyObject *argv[3];
54475
54476 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
54477 --argc;
54478 if (argc == 2) {
54479 int _v = 0;
54480 {
54481 void *vptr = 0;
54482 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54483 _v = SWIG_CheckState(res);
54484 }
54485 if (!_v) goto check_1;
54486 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
54487 }
54488 check_1:
54489
54490 if (argc == 2) {
54491 int _v = 0;
54492 {
54493 void *vptr = 0;
54494 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54495 _v = SWIG_CheckState(res);
54496 }
54497 if (!_v) goto check_2;
54498 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
54499 }
54500 check_2:
54501
54502 if (argc == 2) {
54503 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
54504 }
54505
54506 fail:
54507 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
54508 return NULL;
54509 }
54510
54511
54512 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54513 PyObject *resultobj = 0;
54514 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54515 wxWindow *arg2 = (wxWindow *) 0 ;
54516 wxGBSpan *arg3 = 0 ;
54517 bool result;
54518 void *argp1 = 0 ;
54519 int res1 = 0 ;
54520 void *argp2 = 0 ;
54521 int res2 = 0 ;
54522 wxGBSpan temp3 ;
54523
54524 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54526 if (!SWIG_IsOK(res1)) {
54527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54528 }
54529 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54530 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54531 if (!SWIG_IsOK(res2)) {
54532 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54533 }
54534 arg2 = reinterpret_cast< wxWindow * >(argp2);
54535 {
54536 arg3 = &temp3;
54537 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54538 }
54539 {
54540 PyThreadState* __tstate = wxPyBeginAllowThreads();
54541 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54542 wxPyEndAllowThreads(__tstate);
54543 if (PyErr_Occurred()) SWIG_fail;
54544 }
54545 {
54546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54547 }
54548 return resultobj;
54549 fail:
54550 return NULL;
54551 }
54552
54553
54554 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54555 PyObject *resultobj = 0;
54556 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54557 wxSizer *arg2 = (wxSizer *) 0 ;
54558 wxGBSpan *arg3 = 0 ;
54559 bool result;
54560 void *argp1 = 0 ;
54561 int res1 = 0 ;
54562 void *argp2 = 0 ;
54563 int res2 = 0 ;
54564 wxGBSpan temp3 ;
54565
54566 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54568 if (!SWIG_IsOK(res1)) {
54569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54570 }
54571 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54572 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54573 if (!SWIG_IsOK(res2)) {
54574 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54575 }
54576 arg2 = reinterpret_cast< wxSizer * >(argp2);
54577 {
54578 arg3 = &temp3;
54579 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54580 }
54581 {
54582 PyThreadState* __tstate = wxPyBeginAllowThreads();
54583 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54584 wxPyEndAllowThreads(__tstate);
54585 if (PyErr_Occurred()) SWIG_fail;
54586 }
54587 {
54588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54589 }
54590 return resultobj;
54591 fail:
54592 return NULL;
54593 }
54594
54595
54596 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54597 PyObject *resultobj = 0;
54598 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54599 size_t arg2 ;
54600 wxGBSpan *arg3 = 0 ;
54601 bool result;
54602 void *argp1 = 0 ;
54603 int res1 = 0 ;
54604 size_t val2 ;
54605 int ecode2 = 0 ;
54606 wxGBSpan temp3 ;
54607
54608 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54610 if (!SWIG_IsOK(res1)) {
54611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54612 }
54613 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54614 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54615 if (!SWIG_IsOK(ecode2)) {
54616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54617 }
54618 arg2 = static_cast< size_t >(val2);
54619 {
54620 arg3 = &temp3;
54621 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54622 }
54623 {
54624 PyThreadState* __tstate = wxPyBeginAllowThreads();
54625 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54626 wxPyEndAllowThreads(__tstate);
54627 if (PyErr_Occurred()) SWIG_fail;
54628 }
54629 {
54630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54631 }
54632 return resultobj;
54633 fail:
54634 return NULL;
54635 }
54636
54637
54638 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
54639 int argc;
54640 PyObject *argv[4];
54641
54642 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
54643 --argc;
54644 if (argc == 3) {
54645 int _v = 0;
54646 {
54647 void *vptr = 0;
54648 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54649 _v = SWIG_CheckState(res);
54650 }
54651 if (!_v) goto check_1;
54652 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
54653 }
54654 check_1:
54655
54656 if (argc == 3) {
54657 int _v = 0;
54658 {
54659 void *vptr = 0;
54660 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54661 _v = SWIG_CheckState(res);
54662 }
54663 if (!_v) goto check_2;
54664 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
54665 }
54666 check_2:
54667
54668 if (argc == 3) {
54669 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
54670 }
54671
54672 fail:
54673 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
54674 return NULL;
54675 }
54676
54677
54678 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54679 PyObject *resultobj = 0;
54680 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54681 wxWindow *arg2 = (wxWindow *) 0 ;
54682 wxGBSizerItem *result = 0 ;
54683 void *argp1 = 0 ;
54684 int res1 = 0 ;
54685 void *argp2 = 0 ;
54686 int res2 = 0 ;
54687
54688 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54690 if (!SWIG_IsOK(res1)) {
54691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54692 }
54693 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54694 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54695 if (!SWIG_IsOK(res2)) {
54696 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
54697 }
54698 arg2 = reinterpret_cast< wxWindow * >(argp2);
54699 {
54700 PyThreadState* __tstate = wxPyBeginAllowThreads();
54701 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54702 wxPyEndAllowThreads(__tstate);
54703 if (PyErr_Occurred()) SWIG_fail;
54704 }
54705 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54706 return resultobj;
54707 fail:
54708 return NULL;
54709 }
54710
54711
54712 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54713 PyObject *resultobj = 0;
54714 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54715 wxSizer *arg2 = (wxSizer *) 0 ;
54716 wxGBSizerItem *result = 0 ;
54717 void *argp1 = 0 ;
54718 int res1 = 0 ;
54719 void *argp2 = 0 ;
54720 int res2 = 0 ;
54721
54722 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54724 if (!SWIG_IsOK(res1)) {
54725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54726 }
54727 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54728 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54729 if (!SWIG_IsOK(res2)) {
54730 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
54731 }
54732 arg2 = reinterpret_cast< wxSizer * >(argp2);
54733 {
54734 PyThreadState* __tstate = wxPyBeginAllowThreads();
54735 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54736 wxPyEndAllowThreads(__tstate);
54737 if (PyErr_Occurred()) SWIG_fail;
54738 }
54739 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54740 return resultobj;
54741 fail:
54742 return NULL;
54743 }
54744
54745
54746 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
54747 int argc;
54748 PyObject *argv[3];
54749
54750 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
54751 --argc;
54752 if (argc == 2) {
54753 int _v = 0;
54754 {
54755 void *vptr = 0;
54756 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54757 _v = SWIG_CheckState(res);
54758 }
54759 if (!_v) goto check_1;
54760 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
54761 }
54762 check_1:
54763
54764 if (argc == 2) {
54765 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
54766 }
54767
54768 fail:
54769 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
54770 return NULL;
54771 }
54772
54773
54774 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54775 PyObject *resultobj = 0;
54776 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54777 wxGBPosition *arg2 = 0 ;
54778 wxGBSizerItem *result = 0 ;
54779 void *argp1 = 0 ;
54780 int res1 = 0 ;
54781 wxGBPosition temp2 ;
54782 PyObject * obj0 = 0 ;
54783 PyObject * obj1 = 0 ;
54784 char * kwnames[] = {
54785 (char *) "self",(char *) "pos", NULL
54786 };
54787
54788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
54789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54790 if (!SWIG_IsOK(res1)) {
54791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54792 }
54793 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54794 {
54795 arg2 = &temp2;
54796 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54797 }
54798 {
54799 PyThreadState* __tstate = wxPyBeginAllowThreads();
54800 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
54801 wxPyEndAllowThreads(__tstate);
54802 if (PyErr_Occurred()) SWIG_fail;
54803 }
54804 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54805 return resultobj;
54806 fail:
54807 return NULL;
54808 }
54809
54810
54811 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54812 PyObject *resultobj = 0;
54813 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54814 wxPoint *arg2 = 0 ;
54815 wxGBSizerItem *result = 0 ;
54816 void *argp1 = 0 ;
54817 int res1 = 0 ;
54818 wxPoint temp2 ;
54819 PyObject * obj0 = 0 ;
54820 PyObject * obj1 = 0 ;
54821 char * kwnames[] = {
54822 (char *) "self",(char *) "pt", NULL
54823 };
54824
54825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
54826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54827 if (!SWIG_IsOK(res1)) {
54828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54829 }
54830 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54831 {
54832 arg2 = &temp2;
54833 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
54834 }
54835 {
54836 PyThreadState* __tstate = wxPyBeginAllowThreads();
54837 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
54838 wxPyEndAllowThreads(__tstate);
54839 if (PyErr_Occurred()) SWIG_fail;
54840 }
54841 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54842 return resultobj;
54843 fail:
54844 return NULL;
54845 }
54846
54847
54848 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54849 PyObject *resultobj = 0;
54850 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54851 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
54852 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
54853 bool result;
54854 void *argp1 = 0 ;
54855 int res1 = 0 ;
54856 void *argp2 = 0 ;
54857 int res2 = 0 ;
54858 void *argp3 = 0 ;
54859 int res3 = 0 ;
54860 PyObject * obj0 = 0 ;
54861 PyObject * obj1 = 0 ;
54862 PyObject * obj2 = 0 ;
54863 char * kwnames[] = {
54864 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
54865 };
54866
54867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54869 if (!SWIG_IsOK(res1)) {
54870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54871 }
54872 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54873 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54874 if (!SWIG_IsOK(res2)) {
54875 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
54876 }
54877 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
54878 if (obj2) {
54879 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54880 if (!SWIG_IsOK(res3)) {
54881 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
54882 }
54883 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
54884 }
54885 {
54886 PyThreadState* __tstate = wxPyBeginAllowThreads();
54887 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
54888 wxPyEndAllowThreads(__tstate);
54889 if (PyErr_Occurred()) SWIG_fail;
54890 }
54891 {
54892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54893 }
54894 return resultobj;
54895 fail:
54896 return NULL;
54897 }
54898
54899
54900 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54901 PyObject *resultobj = 0;
54902 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54903 wxGBPosition *arg2 = 0 ;
54904 wxGBSpan *arg3 = 0 ;
54905 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
54906 bool result;
54907 void *argp1 = 0 ;
54908 int res1 = 0 ;
54909 wxGBPosition temp2 ;
54910 wxGBSpan temp3 ;
54911 void *argp4 = 0 ;
54912 int res4 = 0 ;
54913 PyObject * obj0 = 0 ;
54914 PyObject * obj1 = 0 ;
54915 PyObject * obj2 = 0 ;
54916 PyObject * obj3 = 0 ;
54917 char * kwnames[] = {
54918 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
54919 };
54920
54921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
54922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54923 if (!SWIG_IsOK(res1)) {
54924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54925 }
54926 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54927 {
54928 arg2 = &temp2;
54929 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54930 }
54931 {
54932 arg3 = &temp3;
54933 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
54934 }
54935 if (obj3) {
54936 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54937 if (!SWIG_IsOK(res4)) {
54938 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
54939 }
54940 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
54941 }
54942 {
54943 PyThreadState* __tstate = wxPyBeginAllowThreads();
54944 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
54945 wxPyEndAllowThreads(__tstate);
54946 if (PyErr_Occurred()) SWIG_fail;
54947 }
54948 {
54949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54950 }
54951 return resultobj;
54952 fail:
54953 return NULL;
54954 }
54955
54956
54957 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54958 PyObject *obj;
54959 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54960 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
54961 return SWIG_Py_Void();
54962 }
54963
54964 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54965 return SWIG_Python_InitShadowInstance(args);
54966 }
54967
54968 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54969 PyObject *resultobj = 0;
54970 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
54971 wxRelationship arg2 ;
54972 wxWindow *arg3 = (wxWindow *) 0 ;
54973 wxEdge arg4 ;
54974 int arg5 = (int) 0 ;
54975 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
54976 void *argp1 = 0 ;
54977 int res1 = 0 ;
54978 int val2 ;
54979 int ecode2 = 0 ;
54980 void *argp3 = 0 ;
54981 int res3 = 0 ;
54982 int val4 ;
54983 int ecode4 = 0 ;
54984 int val5 ;
54985 int ecode5 = 0 ;
54986 int val6 ;
54987 int ecode6 = 0 ;
54988 PyObject * obj0 = 0 ;
54989 PyObject * obj1 = 0 ;
54990 PyObject * obj2 = 0 ;
54991 PyObject * obj3 = 0 ;
54992 PyObject * obj4 = 0 ;
54993 PyObject * obj5 = 0 ;
54994 char * kwnames[] = {
54995 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
54996 };
54997
54998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
54999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55000 if (!SWIG_IsOK(res1)) {
55001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55002 }
55003 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55004 ecode2 = SWIG_AsVal_int(obj1, &val2);
55005 if (!SWIG_IsOK(ecode2)) {
55006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
55007 }
55008 arg2 = static_cast< wxRelationship >(val2);
55009 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
55010 if (!SWIG_IsOK(res3)) {
55011 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
55012 }
55013 arg3 = reinterpret_cast< wxWindow * >(argp3);
55014 ecode4 = SWIG_AsVal_int(obj3, &val4);
55015 if (!SWIG_IsOK(ecode4)) {
55016 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
55017 }
55018 arg4 = static_cast< wxEdge >(val4);
55019 if (obj4) {
55020 ecode5 = SWIG_AsVal_int(obj4, &val5);
55021 if (!SWIG_IsOK(ecode5)) {
55022 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
55023 }
55024 arg5 = static_cast< int >(val5);
55025 }
55026 if (obj5) {
55027 ecode6 = SWIG_AsVal_int(obj5, &val6);
55028 if (!SWIG_IsOK(ecode6)) {
55029 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
55030 }
55031 arg6 = static_cast< int >(val6);
55032 }
55033 {
55034 PyThreadState* __tstate = wxPyBeginAllowThreads();
55035 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
55036 wxPyEndAllowThreads(__tstate);
55037 if (PyErr_Occurred()) SWIG_fail;
55038 }
55039 resultobj = SWIG_Py_Void();
55040 return resultobj;
55041 fail:
55042 return NULL;
55043 }
55044
55045
55046 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55047 PyObject *resultobj = 0;
55048 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55049 wxWindow *arg2 = (wxWindow *) 0 ;
55050 int arg3 = (int) 0 ;
55051 void *argp1 = 0 ;
55052 int res1 = 0 ;
55053 void *argp2 = 0 ;
55054 int res2 = 0 ;
55055 int val3 ;
55056 int ecode3 = 0 ;
55057 PyObject * obj0 = 0 ;
55058 PyObject * obj1 = 0 ;
55059 PyObject * obj2 = 0 ;
55060 char * kwnames[] = {
55061 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55062 };
55063
55064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55066 if (!SWIG_IsOK(res1)) {
55067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55068 }
55069 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55070 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55071 if (!SWIG_IsOK(res2)) {
55072 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55073 }
55074 arg2 = reinterpret_cast< wxWindow * >(argp2);
55075 if (obj2) {
55076 ecode3 = SWIG_AsVal_int(obj2, &val3);
55077 if (!SWIG_IsOK(ecode3)) {
55078 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
55079 }
55080 arg3 = static_cast< int >(val3);
55081 }
55082 {
55083 PyThreadState* __tstate = wxPyBeginAllowThreads();
55084 (arg1)->LeftOf(arg2,arg3);
55085 wxPyEndAllowThreads(__tstate);
55086 if (PyErr_Occurred()) SWIG_fail;
55087 }
55088 resultobj = SWIG_Py_Void();
55089 return resultobj;
55090 fail:
55091 return NULL;
55092 }
55093
55094
55095 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55096 PyObject *resultobj = 0;
55097 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55098 wxWindow *arg2 = (wxWindow *) 0 ;
55099 int arg3 = (int) 0 ;
55100 void *argp1 = 0 ;
55101 int res1 = 0 ;
55102 void *argp2 = 0 ;
55103 int res2 = 0 ;
55104 int val3 ;
55105 int ecode3 = 0 ;
55106 PyObject * obj0 = 0 ;
55107 PyObject * obj1 = 0 ;
55108 PyObject * obj2 = 0 ;
55109 char * kwnames[] = {
55110 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55111 };
55112
55113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55115 if (!SWIG_IsOK(res1)) {
55116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55117 }
55118 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55119 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55120 if (!SWIG_IsOK(res2)) {
55121 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55122 }
55123 arg2 = reinterpret_cast< wxWindow * >(argp2);
55124 if (obj2) {
55125 ecode3 = SWIG_AsVal_int(obj2, &val3);
55126 if (!SWIG_IsOK(ecode3)) {
55127 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
55128 }
55129 arg3 = static_cast< int >(val3);
55130 }
55131 {
55132 PyThreadState* __tstate = wxPyBeginAllowThreads();
55133 (arg1)->RightOf(arg2,arg3);
55134 wxPyEndAllowThreads(__tstate);
55135 if (PyErr_Occurred()) SWIG_fail;
55136 }
55137 resultobj = SWIG_Py_Void();
55138 return resultobj;
55139 fail:
55140 return NULL;
55141 }
55142
55143
55144 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55145 PyObject *resultobj = 0;
55146 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55147 wxWindow *arg2 = (wxWindow *) 0 ;
55148 int arg3 = (int) 0 ;
55149 void *argp1 = 0 ;
55150 int res1 = 0 ;
55151 void *argp2 = 0 ;
55152 int res2 = 0 ;
55153 int val3 ;
55154 int ecode3 = 0 ;
55155 PyObject * obj0 = 0 ;
55156 PyObject * obj1 = 0 ;
55157 PyObject * obj2 = 0 ;
55158 char * kwnames[] = {
55159 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55160 };
55161
55162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55164 if (!SWIG_IsOK(res1)) {
55165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55166 }
55167 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55168 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55169 if (!SWIG_IsOK(res2)) {
55170 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
55171 }
55172 arg2 = reinterpret_cast< wxWindow * >(argp2);
55173 if (obj2) {
55174 ecode3 = SWIG_AsVal_int(obj2, &val3);
55175 if (!SWIG_IsOK(ecode3)) {
55176 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
55177 }
55178 arg3 = static_cast< int >(val3);
55179 }
55180 {
55181 PyThreadState* __tstate = wxPyBeginAllowThreads();
55182 (arg1)->Above(arg2,arg3);
55183 wxPyEndAllowThreads(__tstate);
55184 if (PyErr_Occurred()) SWIG_fail;
55185 }
55186 resultobj = SWIG_Py_Void();
55187 return resultobj;
55188 fail:
55189 return NULL;
55190 }
55191
55192
55193 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55194 PyObject *resultobj = 0;
55195 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55196 wxWindow *arg2 = (wxWindow *) 0 ;
55197 int arg3 = (int) 0 ;
55198 void *argp1 = 0 ;
55199 int res1 = 0 ;
55200 void *argp2 = 0 ;
55201 int res2 = 0 ;
55202 int val3 ;
55203 int ecode3 = 0 ;
55204 PyObject * obj0 = 0 ;
55205 PyObject * obj1 = 0 ;
55206 PyObject * obj2 = 0 ;
55207 char * kwnames[] = {
55208 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55209 };
55210
55211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55213 if (!SWIG_IsOK(res1)) {
55214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55215 }
55216 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55217 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55218 if (!SWIG_IsOK(res2)) {
55219 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
55220 }
55221 arg2 = reinterpret_cast< wxWindow * >(argp2);
55222 if (obj2) {
55223 ecode3 = SWIG_AsVal_int(obj2, &val3);
55224 if (!SWIG_IsOK(ecode3)) {
55225 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
55226 }
55227 arg3 = static_cast< int >(val3);
55228 }
55229 {
55230 PyThreadState* __tstate = wxPyBeginAllowThreads();
55231 (arg1)->Below(arg2,arg3);
55232 wxPyEndAllowThreads(__tstate);
55233 if (PyErr_Occurred()) SWIG_fail;
55234 }
55235 resultobj = SWIG_Py_Void();
55236 return resultobj;
55237 fail:
55238 return NULL;
55239 }
55240
55241
55242 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55243 PyObject *resultobj = 0;
55244 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55245 wxWindow *arg2 = (wxWindow *) 0 ;
55246 wxEdge arg3 ;
55247 int arg4 = (int) 0 ;
55248 void *argp1 = 0 ;
55249 int res1 = 0 ;
55250 void *argp2 = 0 ;
55251 int res2 = 0 ;
55252 int val3 ;
55253 int ecode3 = 0 ;
55254 int val4 ;
55255 int ecode4 = 0 ;
55256 PyObject * obj0 = 0 ;
55257 PyObject * obj1 = 0 ;
55258 PyObject * obj2 = 0 ;
55259 PyObject * obj3 = 0 ;
55260 char * kwnames[] = {
55261 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
55262 };
55263
55264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55266 if (!SWIG_IsOK(res1)) {
55267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55268 }
55269 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55270 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55271 if (!SWIG_IsOK(res2)) {
55272 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
55273 }
55274 arg2 = reinterpret_cast< wxWindow * >(argp2);
55275 ecode3 = SWIG_AsVal_int(obj2, &val3);
55276 if (!SWIG_IsOK(ecode3)) {
55277 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
55278 }
55279 arg3 = static_cast< wxEdge >(val3);
55280 if (obj3) {
55281 ecode4 = SWIG_AsVal_int(obj3, &val4);
55282 if (!SWIG_IsOK(ecode4)) {
55283 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
55284 }
55285 arg4 = static_cast< int >(val4);
55286 }
55287 {
55288 PyThreadState* __tstate = wxPyBeginAllowThreads();
55289 (arg1)->SameAs(arg2,arg3,arg4);
55290 wxPyEndAllowThreads(__tstate);
55291 if (PyErr_Occurred()) SWIG_fail;
55292 }
55293 resultobj = SWIG_Py_Void();
55294 return resultobj;
55295 fail:
55296 return NULL;
55297 }
55298
55299
55300 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55301 PyObject *resultobj = 0;
55302 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55303 wxWindow *arg2 = (wxWindow *) 0 ;
55304 wxEdge arg3 ;
55305 int arg4 ;
55306 void *argp1 = 0 ;
55307 int res1 = 0 ;
55308 void *argp2 = 0 ;
55309 int res2 = 0 ;
55310 int val3 ;
55311 int ecode3 = 0 ;
55312 int val4 ;
55313 int ecode4 = 0 ;
55314 PyObject * obj0 = 0 ;
55315 PyObject * obj1 = 0 ;
55316 PyObject * obj2 = 0 ;
55317 PyObject * obj3 = 0 ;
55318 char * kwnames[] = {
55319 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
55320 };
55321
55322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55324 if (!SWIG_IsOK(res1)) {
55325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55326 }
55327 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55328 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55329 if (!SWIG_IsOK(res2)) {
55330 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55331 }
55332 arg2 = reinterpret_cast< wxWindow * >(argp2);
55333 ecode3 = SWIG_AsVal_int(obj2, &val3);
55334 if (!SWIG_IsOK(ecode3)) {
55335 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
55336 }
55337 arg3 = static_cast< wxEdge >(val3);
55338 ecode4 = SWIG_AsVal_int(obj3, &val4);
55339 if (!SWIG_IsOK(ecode4)) {
55340 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
55341 }
55342 arg4 = static_cast< int >(val4);
55343 {
55344 PyThreadState* __tstate = wxPyBeginAllowThreads();
55345 (arg1)->PercentOf(arg2,arg3,arg4);
55346 wxPyEndAllowThreads(__tstate);
55347 if (PyErr_Occurred()) SWIG_fail;
55348 }
55349 resultobj = SWIG_Py_Void();
55350 return resultobj;
55351 fail:
55352 return NULL;
55353 }
55354
55355
55356 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55357 PyObject *resultobj = 0;
55358 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55359 int arg2 ;
55360 void *argp1 = 0 ;
55361 int res1 = 0 ;
55362 int val2 ;
55363 int ecode2 = 0 ;
55364 PyObject * obj0 = 0 ;
55365 PyObject * obj1 = 0 ;
55366 char * kwnames[] = {
55367 (char *) "self",(char *) "val", NULL
55368 };
55369
55370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
55371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55372 if (!SWIG_IsOK(res1)) {
55373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55374 }
55375 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55376 ecode2 = SWIG_AsVal_int(obj1, &val2);
55377 if (!SWIG_IsOK(ecode2)) {
55378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
55379 }
55380 arg2 = static_cast< int >(val2);
55381 {
55382 PyThreadState* __tstate = wxPyBeginAllowThreads();
55383 (arg1)->Absolute(arg2);
55384 wxPyEndAllowThreads(__tstate);
55385 if (PyErr_Occurred()) SWIG_fail;
55386 }
55387 resultobj = SWIG_Py_Void();
55388 return resultobj;
55389 fail:
55390 return NULL;
55391 }
55392
55393
55394 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55395 PyObject *resultobj = 0;
55396 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55397 void *argp1 = 0 ;
55398 int res1 = 0 ;
55399 PyObject *swig_obj[1] ;
55400
55401 if (!args) SWIG_fail;
55402 swig_obj[0] = args;
55403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55404 if (!SWIG_IsOK(res1)) {
55405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55406 }
55407 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55408 {
55409 PyThreadState* __tstate = wxPyBeginAllowThreads();
55410 (arg1)->Unconstrained();
55411 wxPyEndAllowThreads(__tstate);
55412 if (PyErr_Occurred()) SWIG_fail;
55413 }
55414 resultobj = SWIG_Py_Void();
55415 return resultobj;
55416 fail:
55417 return NULL;
55418 }
55419
55420
55421 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55422 PyObject *resultobj = 0;
55423 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55424 void *argp1 = 0 ;
55425 int res1 = 0 ;
55426 PyObject *swig_obj[1] ;
55427
55428 if (!args) SWIG_fail;
55429 swig_obj[0] = args;
55430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55431 if (!SWIG_IsOK(res1)) {
55432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55433 }
55434 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55435 {
55436 PyThreadState* __tstate = wxPyBeginAllowThreads();
55437 (arg1)->AsIs();
55438 wxPyEndAllowThreads(__tstate);
55439 if (PyErr_Occurred()) SWIG_fail;
55440 }
55441 resultobj = SWIG_Py_Void();
55442 return resultobj;
55443 fail:
55444 return NULL;
55445 }
55446
55447
55448 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55449 PyObject *resultobj = 0;
55450 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55451 wxWindow *result = 0 ;
55452 void *argp1 = 0 ;
55453 int res1 = 0 ;
55454 PyObject *swig_obj[1] ;
55455
55456 if (!args) SWIG_fail;
55457 swig_obj[0] = args;
55458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55459 if (!SWIG_IsOK(res1)) {
55460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55461 }
55462 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55463 {
55464 PyThreadState* __tstate = wxPyBeginAllowThreads();
55465 result = (wxWindow *)(arg1)->GetOtherWindow();
55466 wxPyEndAllowThreads(__tstate);
55467 if (PyErr_Occurred()) SWIG_fail;
55468 }
55469 {
55470 resultobj = wxPyMake_wxObject(result, 0);
55471 }
55472 return resultobj;
55473 fail:
55474 return NULL;
55475 }
55476
55477
55478 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55479 PyObject *resultobj = 0;
55480 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55481 wxEdge result;
55482 void *argp1 = 0 ;
55483 int res1 = 0 ;
55484 PyObject *swig_obj[1] ;
55485
55486 if (!args) SWIG_fail;
55487 swig_obj[0] = args;
55488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55489 if (!SWIG_IsOK(res1)) {
55490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55491 }
55492 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55493 {
55494 PyThreadState* __tstate = wxPyBeginAllowThreads();
55495 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
55496 wxPyEndAllowThreads(__tstate);
55497 if (PyErr_Occurred()) SWIG_fail;
55498 }
55499 resultobj = SWIG_From_int(static_cast< int >(result));
55500 return resultobj;
55501 fail:
55502 return NULL;
55503 }
55504
55505
55506 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55507 PyObject *resultobj = 0;
55508 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55509 wxEdge arg2 ;
55510 void *argp1 = 0 ;
55511 int res1 = 0 ;
55512 int val2 ;
55513 int ecode2 = 0 ;
55514 PyObject * obj0 = 0 ;
55515 PyObject * obj1 = 0 ;
55516 char * kwnames[] = {
55517 (char *) "self",(char *) "which", NULL
55518 };
55519
55520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
55521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55522 if (!SWIG_IsOK(res1)) {
55523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55524 }
55525 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55526 ecode2 = SWIG_AsVal_int(obj1, &val2);
55527 if (!SWIG_IsOK(ecode2)) {
55528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
55529 }
55530 arg2 = static_cast< wxEdge >(val2);
55531 {
55532 PyThreadState* __tstate = wxPyBeginAllowThreads();
55533 (arg1)->SetEdge(arg2);
55534 wxPyEndAllowThreads(__tstate);
55535 if (PyErr_Occurred()) SWIG_fail;
55536 }
55537 resultobj = SWIG_Py_Void();
55538 return resultobj;
55539 fail:
55540 return NULL;
55541 }
55542
55543
55544 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55545 PyObject *resultobj = 0;
55546 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55547 int arg2 ;
55548 void *argp1 = 0 ;
55549 int res1 = 0 ;
55550 int val2 ;
55551 int ecode2 = 0 ;
55552 PyObject * obj0 = 0 ;
55553 PyObject * obj1 = 0 ;
55554 char * kwnames[] = {
55555 (char *) "self",(char *) "v", NULL
55556 };
55557
55558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
55559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55560 if (!SWIG_IsOK(res1)) {
55561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55562 }
55563 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55564 ecode2 = SWIG_AsVal_int(obj1, &val2);
55565 if (!SWIG_IsOK(ecode2)) {
55566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
55567 }
55568 arg2 = static_cast< int >(val2);
55569 {
55570 PyThreadState* __tstate = wxPyBeginAllowThreads();
55571 (arg1)->SetValue(arg2);
55572 wxPyEndAllowThreads(__tstate);
55573 if (PyErr_Occurred()) SWIG_fail;
55574 }
55575 resultobj = SWIG_Py_Void();
55576 return resultobj;
55577 fail:
55578 return NULL;
55579 }
55580
55581
55582 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55583 PyObject *resultobj = 0;
55584 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55585 int result;
55586 void *argp1 = 0 ;
55587 int res1 = 0 ;
55588 PyObject *swig_obj[1] ;
55589
55590 if (!args) SWIG_fail;
55591 swig_obj[0] = args;
55592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55593 if (!SWIG_IsOK(res1)) {
55594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55595 }
55596 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55597 {
55598 PyThreadState* __tstate = wxPyBeginAllowThreads();
55599 result = (int)(arg1)->GetMargin();
55600 wxPyEndAllowThreads(__tstate);
55601 if (PyErr_Occurred()) SWIG_fail;
55602 }
55603 resultobj = SWIG_From_int(static_cast< int >(result));
55604 return resultobj;
55605 fail:
55606 return NULL;
55607 }
55608
55609
55610 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55611 PyObject *resultobj = 0;
55612 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55613 int arg2 ;
55614 void *argp1 = 0 ;
55615 int res1 = 0 ;
55616 int val2 ;
55617 int ecode2 = 0 ;
55618 PyObject * obj0 = 0 ;
55619 PyObject * obj1 = 0 ;
55620 char * kwnames[] = {
55621 (char *) "self",(char *) "m", NULL
55622 };
55623
55624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
55625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55626 if (!SWIG_IsOK(res1)) {
55627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55628 }
55629 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55630 ecode2 = SWIG_AsVal_int(obj1, &val2);
55631 if (!SWIG_IsOK(ecode2)) {
55632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
55633 }
55634 arg2 = static_cast< int >(val2);
55635 {
55636 PyThreadState* __tstate = wxPyBeginAllowThreads();
55637 (arg1)->SetMargin(arg2);
55638 wxPyEndAllowThreads(__tstate);
55639 if (PyErr_Occurred()) SWIG_fail;
55640 }
55641 resultobj = SWIG_Py_Void();
55642 return resultobj;
55643 fail:
55644 return NULL;
55645 }
55646
55647
55648 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55649 PyObject *resultobj = 0;
55650 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55651 int result;
55652 void *argp1 = 0 ;
55653 int res1 = 0 ;
55654 PyObject *swig_obj[1] ;
55655
55656 if (!args) SWIG_fail;
55657 swig_obj[0] = args;
55658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55659 if (!SWIG_IsOK(res1)) {
55660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55661 }
55662 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55663 {
55664 PyThreadState* __tstate = wxPyBeginAllowThreads();
55665 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
55666 wxPyEndAllowThreads(__tstate);
55667 if (PyErr_Occurred()) SWIG_fail;
55668 }
55669 resultobj = SWIG_From_int(static_cast< int >(result));
55670 return resultobj;
55671 fail:
55672 return NULL;
55673 }
55674
55675
55676 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55677 PyObject *resultobj = 0;
55678 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55679 int result;
55680 void *argp1 = 0 ;
55681 int res1 = 0 ;
55682 PyObject *swig_obj[1] ;
55683
55684 if (!args) SWIG_fail;
55685 swig_obj[0] = args;
55686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55687 if (!SWIG_IsOK(res1)) {
55688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55689 }
55690 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55691 {
55692 PyThreadState* __tstate = wxPyBeginAllowThreads();
55693 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
55694 wxPyEndAllowThreads(__tstate);
55695 if (PyErr_Occurred()) SWIG_fail;
55696 }
55697 resultobj = SWIG_From_int(static_cast< int >(result));
55698 return resultobj;
55699 fail:
55700 return NULL;
55701 }
55702
55703
55704 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55705 PyObject *resultobj = 0;
55706 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55707 int result;
55708 void *argp1 = 0 ;
55709 int res1 = 0 ;
55710 PyObject *swig_obj[1] ;
55711
55712 if (!args) SWIG_fail;
55713 swig_obj[0] = args;
55714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55715 if (!SWIG_IsOK(res1)) {
55716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55717 }
55718 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55719 {
55720 PyThreadState* __tstate = wxPyBeginAllowThreads();
55721 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
55722 wxPyEndAllowThreads(__tstate);
55723 if (PyErr_Occurred()) SWIG_fail;
55724 }
55725 resultobj = SWIG_From_int(static_cast< int >(result));
55726 return resultobj;
55727 fail:
55728 return NULL;
55729 }
55730
55731
55732 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55733 PyObject *resultobj = 0;
55734 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55735 bool result;
55736 void *argp1 = 0 ;
55737 int res1 = 0 ;
55738 PyObject *swig_obj[1] ;
55739
55740 if (!args) SWIG_fail;
55741 swig_obj[0] = args;
55742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55743 if (!SWIG_IsOK(res1)) {
55744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55745 }
55746 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55747 {
55748 PyThreadState* __tstate = wxPyBeginAllowThreads();
55749 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
55750 wxPyEndAllowThreads(__tstate);
55751 if (PyErr_Occurred()) SWIG_fail;
55752 }
55753 {
55754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55755 }
55756 return resultobj;
55757 fail:
55758 return NULL;
55759 }
55760
55761
55762 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55763 PyObject *resultobj = 0;
55764 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55765 bool arg2 ;
55766 void *argp1 = 0 ;
55767 int res1 = 0 ;
55768 bool val2 ;
55769 int ecode2 = 0 ;
55770 PyObject * obj0 = 0 ;
55771 PyObject * obj1 = 0 ;
55772 char * kwnames[] = {
55773 (char *) "self",(char *) "d", NULL
55774 };
55775
55776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
55777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55778 if (!SWIG_IsOK(res1)) {
55779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55780 }
55781 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55782 ecode2 = SWIG_AsVal_bool(obj1, &val2);
55783 if (!SWIG_IsOK(ecode2)) {
55784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
55785 }
55786 arg2 = static_cast< bool >(val2);
55787 {
55788 PyThreadState* __tstate = wxPyBeginAllowThreads();
55789 (arg1)->SetDone(arg2);
55790 wxPyEndAllowThreads(__tstate);
55791 if (PyErr_Occurred()) SWIG_fail;
55792 }
55793 resultobj = SWIG_Py_Void();
55794 return resultobj;
55795 fail:
55796 return NULL;
55797 }
55798
55799
55800 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55801 PyObject *resultobj = 0;
55802 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55803 wxRelationship result;
55804 void *argp1 = 0 ;
55805 int res1 = 0 ;
55806 PyObject *swig_obj[1] ;
55807
55808 if (!args) SWIG_fail;
55809 swig_obj[0] = args;
55810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55811 if (!SWIG_IsOK(res1)) {
55812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55813 }
55814 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55815 {
55816 PyThreadState* __tstate = wxPyBeginAllowThreads();
55817 result = (wxRelationship)(arg1)->GetRelationship();
55818 wxPyEndAllowThreads(__tstate);
55819 if (PyErr_Occurred()) SWIG_fail;
55820 }
55821 resultobj = SWIG_From_int(static_cast< int >(result));
55822 return resultobj;
55823 fail:
55824 return NULL;
55825 }
55826
55827
55828 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55829 PyObject *resultobj = 0;
55830 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55831 wxRelationship arg2 ;
55832 void *argp1 = 0 ;
55833 int res1 = 0 ;
55834 int val2 ;
55835 int ecode2 = 0 ;
55836 PyObject * obj0 = 0 ;
55837 PyObject * obj1 = 0 ;
55838 char * kwnames[] = {
55839 (char *) "self",(char *) "r", NULL
55840 };
55841
55842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
55843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55844 if (!SWIG_IsOK(res1)) {
55845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55846 }
55847 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55848 ecode2 = SWIG_AsVal_int(obj1, &val2);
55849 if (!SWIG_IsOK(ecode2)) {
55850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
55851 }
55852 arg2 = static_cast< wxRelationship >(val2);
55853 {
55854 PyThreadState* __tstate = wxPyBeginAllowThreads();
55855 (arg1)->SetRelationship(arg2);
55856 wxPyEndAllowThreads(__tstate);
55857 if (PyErr_Occurred()) SWIG_fail;
55858 }
55859 resultobj = SWIG_Py_Void();
55860 return resultobj;
55861 fail:
55862 return NULL;
55863 }
55864
55865
55866 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55867 PyObject *resultobj = 0;
55868 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55869 wxWindow *arg2 = (wxWindow *) 0 ;
55870 bool result;
55871 void *argp1 = 0 ;
55872 int res1 = 0 ;
55873 void *argp2 = 0 ;
55874 int res2 = 0 ;
55875 PyObject * obj0 = 0 ;
55876 PyObject * obj1 = 0 ;
55877 char * kwnames[] = {
55878 (char *) "self",(char *) "otherW", NULL
55879 };
55880
55881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
55882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55883 if (!SWIG_IsOK(res1)) {
55884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55885 }
55886 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55887 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55888 if (!SWIG_IsOK(res2)) {
55889 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
55890 }
55891 arg2 = reinterpret_cast< wxWindow * >(argp2);
55892 {
55893 PyThreadState* __tstate = wxPyBeginAllowThreads();
55894 result = (bool)(arg1)->ResetIfWin(arg2);
55895 wxPyEndAllowThreads(__tstate);
55896 if (PyErr_Occurred()) SWIG_fail;
55897 }
55898 {
55899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55900 }
55901 return resultobj;
55902 fail:
55903 return NULL;
55904 }
55905
55906
55907 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55908 PyObject *resultobj = 0;
55909 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55910 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
55911 wxWindow *arg3 = (wxWindow *) 0 ;
55912 bool result;
55913 void *argp1 = 0 ;
55914 int res1 = 0 ;
55915 void *argp2 = 0 ;
55916 int res2 = 0 ;
55917 void *argp3 = 0 ;
55918 int res3 = 0 ;
55919 PyObject * obj0 = 0 ;
55920 PyObject * obj1 = 0 ;
55921 PyObject * obj2 = 0 ;
55922 char * kwnames[] = {
55923 (char *) "self",(char *) "constraints",(char *) "win", NULL
55924 };
55925
55926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55928 if (!SWIG_IsOK(res1)) {
55929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55930 }
55931 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55932 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
55933 if (!SWIG_IsOK(res2)) {
55934 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
55935 }
55936 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
55937 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
55938 if (!SWIG_IsOK(res3)) {
55939 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
55940 }
55941 arg3 = reinterpret_cast< wxWindow * >(argp3);
55942 {
55943 PyThreadState* __tstate = wxPyBeginAllowThreads();
55944 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
55945 wxPyEndAllowThreads(__tstate);
55946 if (PyErr_Occurred()) SWIG_fail;
55947 }
55948 {
55949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55950 }
55951 return resultobj;
55952 fail:
55953 return NULL;
55954 }
55955
55956
55957 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55958 PyObject *resultobj = 0;
55959 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55960 wxEdge arg2 ;
55961 wxWindow *arg3 = (wxWindow *) 0 ;
55962 wxWindow *arg4 = (wxWindow *) 0 ;
55963 int result;
55964 void *argp1 = 0 ;
55965 int res1 = 0 ;
55966 int val2 ;
55967 int ecode2 = 0 ;
55968 void *argp3 = 0 ;
55969 int res3 = 0 ;
55970 void *argp4 = 0 ;
55971 int res4 = 0 ;
55972 PyObject * obj0 = 0 ;
55973 PyObject * obj1 = 0 ;
55974 PyObject * obj2 = 0 ;
55975 PyObject * obj3 = 0 ;
55976 char * kwnames[] = {
55977 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
55978 };
55979
55980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55982 if (!SWIG_IsOK(res1)) {
55983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55984 }
55985 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55986 ecode2 = SWIG_AsVal_int(obj1, &val2);
55987 if (!SWIG_IsOK(ecode2)) {
55988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
55989 }
55990 arg2 = static_cast< wxEdge >(val2);
55991 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
55992 if (!SWIG_IsOK(res3)) {
55993 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
55994 }
55995 arg3 = reinterpret_cast< wxWindow * >(argp3);
55996 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
55997 if (!SWIG_IsOK(res4)) {
55998 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
55999 }
56000 arg4 = reinterpret_cast< wxWindow * >(argp4);
56001 {
56002 PyThreadState* __tstate = wxPyBeginAllowThreads();
56003 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
56004 wxPyEndAllowThreads(__tstate);
56005 if (PyErr_Occurred()) SWIG_fail;
56006 }
56007 resultobj = SWIG_From_int(static_cast< int >(result));
56008 return resultobj;
56009 fail:
56010 return NULL;
56011 }
56012
56013
56014 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56015 PyObject *obj;
56016 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56017 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
56018 return SWIG_Py_Void();
56019 }
56020
56021 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56022 PyObject *resultobj = 0;
56023 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56024 wxIndividualLayoutConstraint *result = 0 ;
56025 void *argp1 = 0 ;
56026 int res1 = 0 ;
56027 PyObject *swig_obj[1] ;
56028
56029 if (!args) SWIG_fail;
56030 swig_obj[0] = args;
56031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56032 if (!SWIG_IsOK(res1)) {
56033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56034 }
56035 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56036 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
56037 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56038 return resultobj;
56039 fail:
56040 return NULL;
56041 }
56042
56043
56044 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56045 PyObject *resultobj = 0;
56046 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56047 wxIndividualLayoutConstraint *result = 0 ;
56048 void *argp1 = 0 ;
56049 int res1 = 0 ;
56050 PyObject *swig_obj[1] ;
56051
56052 if (!args) SWIG_fail;
56053 swig_obj[0] = args;
56054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56055 if (!SWIG_IsOK(res1)) {
56056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56057 }
56058 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56059 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
56060 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56061 return resultobj;
56062 fail:
56063 return NULL;
56064 }
56065
56066
56067 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56068 PyObject *resultobj = 0;
56069 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56070 wxIndividualLayoutConstraint *result = 0 ;
56071 void *argp1 = 0 ;
56072 int res1 = 0 ;
56073 PyObject *swig_obj[1] ;
56074
56075 if (!args) SWIG_fail;
56076 swig_obj[0] = args;
56077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56078 if (!SWIG_IsOK(res1)) {
56079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56080 }
56081 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56082 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
56083 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56084 return resultobj;
56085 fail:
56086 return NULL;
56087 }
56088
56089
56090 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56091 PyObject *resultobj = 0;
56092 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56093 wxIndividualLayoutConstraint *result = 0 ;
56094 void *argp1 = 0 ;
56095 int res1 = 0 ;
56096 PyObject *swig_obj[1] ;
56097
56098 if (!args) SWIG_fail;
56099 swig_obj[0] = args;
56100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56101 if (!SWIG_IsOK(res1)) {
56102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56103 }
56104 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56105 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
56106 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56107 return resultobj;
56108 fail:
56109 return NULL;
56110 }
56111
56112
56113 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56114 PyObject *resultobj = 0;
56115 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56116 wxIndividualLayoutConstraint *result = 0 ;
56117 void *argp1 = 0 ;
56118 int res1 = 0 ;
56119 PyObject *swig_obj[1] ;
56120
56121 if (!args) SWIG_fail;
56122 swig_obj[0] = args;
56123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56124 if (!SWIG_IsOK(res1)) {
56125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56126 }
56127 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56128 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
56129 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56130 return resultobj;
56131 fail:
56132 return NULL;
56133 }
56134
56135
56136 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56137 PyObject *resultobj = 0;
56138 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56139 wxIndividualLayoutConstraint *result = 0 ;
56140 void *argp1 = 0 ;
56141 int res1 = 0 ;
56142 PyObject *swig_obj[1] ;
56143
56144 if (!args) SWIG_fail;
56145 swig_obj[0] = args;
56146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56147 if (!SWIG_IsOK(res1)) {
56148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56149 }
56150 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56151 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
56152 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56153 return resultobj;
56154 fail:
56155 return NULL;
56156 }
56157
56158
56159 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56160 PyObject *resultobj = 0;
56161 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56162 wxIndividualLayoutConstraint *result = 0 ;
56163 void *argp1 = 0 ;
56164 int res1 = 0 ;
56165 PyObject *swig_obj[1] ;
56166
56167 if (!args) SWIG_fail;
56168 swig_obj[0] = args;
56169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56170 if (!SWIG_IsOK(res1)) {
56171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56172 }
56173 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56174 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
56175 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56176 return resultobj;
56177 fail:
56178 return NULL;
56179 }
56180
56181
56182 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56183 PyObject *resultobj = 0;
56184 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56185 wxIndividualLayoutConstraint *result = 0 ;
56186 void *argp1 = 0 ;
56187 int res1 = 0 ;
56188 PyObject *swig_obj[1] ;
56189
56190 if (!args) SWIG_fail;
56191 swig_obj[0] = args;
56192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56193 if (!SWIG_IsOK(res1)) {
56194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56195 }
56196 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56197 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
56198 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56199 return resultobj;
56200 fail:
56201 return NULL;
56202 }
56203
56204
56205 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56206 PyObject *resultobj = 0;
56207 wxLayoutConstraints *result = 0 ;
56208
56209 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
56210 {
56211 PyThreadState* __tstate = wxPyBeginAllowThreads();
56212 result = (wxLayoutConstraints *)new wxLayoutConstraints();
56213 wxPyEndAllowThreads(__tstate);
56214 if (PyErr_Occurred()) SWIG_fail;
56215 }
56216 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
56217 return resultobj;
56218 fail:
56219 return NULL;
56220 }
56221
56222
56223 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56224 PyObject *resultobj = 0;
56225 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56226 void *argp1 = 0 ;
56227 int res1 = 0 ;
56228 PyObject *swig_obj[1] ;
56229
56230 if (!args) SWIG_fail;
56231 swig_obj[0] = args;
56232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
56233 if (!SWIG_IsOK(res1)) {
56234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56235 }
56236 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56237 {
56238 PyThreadState* __tstate = wxPyBeginAllowThreads();
56239 delete arg1;
56240
56241 wxPyEndAllowThreads(__tstate);
56242 if (PyErr_Occurred()) SWIG_fail;
56243 }
56244 resultobj = SWIG_Py_Void();
56245 return resultobj;
56246 fail:
56247 return NULL;
56248 }
56249
56250
56251 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56252 PyObject *resultobj = 0;
56253 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56254 wxWindow *arg2 = (wxWindow *) 0 ;
56255 int *arg3 = (int *) 0 ;
56256 bool result;
56257 void *argp1 = 0 ;
56258 int res1 = 0 ;
56259 void *argp2 = 0 ;
56260 int res2 = 0 ;
56261 int temp3 ;
56262 int res3 = SWIG_TMPOBJ ;
56263 PyObject * obj0 = 0 ;
56264 PyObject * obj1 = 0 ;
56265 char * kwnames[] = {
56266 (char *) "self",(char *) "win", NULL
56267 };
56268
56269 arg3 = &temp3;
56270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
56271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56272 if (!SWIG_IsOK(res1)) {
56273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56274 }
56275 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56276 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56277 if (!SWIG_IsOK(res2)) {
56278 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
56279 }
56280 arg2 = reinterpret_cast< wxWindow * >(argp2);
56281 {
56282 PyThreadState* __tstate = wxPyBeginAllowThreads();
56283 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
56284 wxPyEndAllowThreads(__tstate);
56285 if (PyErr_Occurred()) SWIG_fail;
56286 }
56287 {
56288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56289 }
56290 if (SWIG_IsTmpObj(res3)) {
56291 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
56292 } else {
56293 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
56294 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
56295 }
56296 return resultobj;
56297 fail:
56298 return NULL;
56299 }
56300
56301
56302 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56303 PyObject *resultobj = 0;
56304 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56305 bool result;
56306 void *argp1 = 0 ;
56307 int res1 = 0 ;
56308 PyObject *swig_obj[1] ;
56309
56310 if (!args) SWIG_fail;
56311 swig_obj[0] = args;
56312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56313 if (!SWIG_IsOK(res1)) {
56314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
56315 }
56316 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56317 {
56318 PyThreadState* __tstate = wxPyBeginAllowThreads();
56319 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
56320 wxPyEndAllowThreads(__tstate);
56321 if (PyErr_Occurred()) SWIG_fail;
56322 }
56323 {
56324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56325 }
56326 return resultobj;
56327 fail:
56328 return NULL;
56329 }
56330
56331
56332 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56333 PyObject *obj;
56334 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56335 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
56336 return SWIG_Py_Void();
56337 }
56338
56339 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56340 return SWIG_Python_InitShadowInstance(args);
56341 }
56342
56343 static PyMethodDef SwigMethods[] = {
56344 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
56345 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
56346 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
56347 { (char *)"Object_IsSameAs", (PyCFunction) _wrap_Object_IsSameAs, METH_VARARGS | METH_KEYWORDS, NULL},
56348 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
56349 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
56350 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
56351 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
56352 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
56353 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56354 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
56355 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56356 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56357 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56358 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56359 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
56360 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
56361 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
56362 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
56363 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56364 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56365 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56366 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56367 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
56368 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
56369 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
56370 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
56371 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
56372 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
56373 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
56374 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
56375 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
56376 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
56377 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
56378 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56379 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
56380 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56381 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56382 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56383 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56384 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56385 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
56386 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
56387 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
56388 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
56389 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
56390 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
56391 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
56392 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
56393 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
56394 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56395 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56396 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56397 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56398 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56399 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56400 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56401 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
56402 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
56403 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
56404 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
56405 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
56406 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
56407 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
56408 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
56409 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
56410 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
56411 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
56412 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
56413 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
56414 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56415 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
56416 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56417 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
56418 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56419 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
56420 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
56421 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
56422 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
56423 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56424 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
56425 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
56426 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
56427 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
56428 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
56429 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56430 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
56431 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
56432 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
56433 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
56434 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56435 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56436 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56437 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56438 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
56439 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
56440 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
56441 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56442 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56443 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56444 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56445 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56446 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56447 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56448 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
56449 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56450 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56451 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56452 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
56453 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
56454 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
56455 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
56456 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
56457 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
56458 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
56459 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
56460 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
56461 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56462 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
56463 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
56464 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
56465 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
56466 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
56467 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
56468 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56469 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
56470 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
56471 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
56472 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
56473 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
56474 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
56475 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
56476 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
56477 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
56478 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56479 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56480 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
56481 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56482 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56483 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
56484 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
56485 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56486 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56487 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
56488 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
56489 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
56490 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
56491 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56492 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
56493 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
56494 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
56495 { (char *)"new_Rect2D", (PyCFunction) _wrap_new_Rect2D, METH_VARARGS | METH_KEYWORDS, NULL},
56496 { (char *)"delete_Rect2D", (PyCFunction)_wrap_delete_Rect2D, METH_O, NULL},
56497 { (char *)"Rect2D_GetPosition", (PyCFunction)_wrap_Rect2D_GetPosition, METH_O, NULL},
56498 { (char *)"Rect2D_GetSize", (PyCFunction)_wrap_Rect2D_GetSize, METH_O, NULL},
56499 { (char *)"Rect2D_GetLeft", (PyCFunction)_wrap_Rect2D_GetLeft, METH_O, NULL},
56500 { (char *)"Rect2D_SetLeft", (PyCFunction) _wrap_Rect2D_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56501 { (char *)"Rect2D_MoveLeftTo", (PyCFunction) _wrap_Rect2D_MoveLeftTo, METH_VARARGS | METH_KEYWORDS, NULL},
56502 { (char *)"Rect2D_GetTop", (PyCFunction)_wrap_Rect2D_GetTop, METH_O, NULL},
56503 { (char *)"Rect2D_SetTop", (PyCFunction) _wrap_Rect2D_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56504 { (char *)"Rect2D_MoveTopTo", (PyCFunction) _wrap_Rect2D_MoveTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56505 { (char *)"Rect2D_GetBottom", (PyCFunction)_wrap_Rect2D_GetBottom, METH_O, NULL},
56506 { (char *)"Rect2D_SetBottom", (PyCFunction) _wrap_Rect2D_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56507 { (char *)"Rect2D_MoveBottomTo", (PyCFunction) _wrap_Rect2D_MoveBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56508 { (char *)"Rect2D_GetRight", (PyCFunction)_wrap_Rect2D_GetRight, METH_O, NULL},
56509 { (char *)"Rect2D_SetRight", (PyCFunction) _wrap_Rect2D_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56510 { (char *)"Rect2D_MoveRightTo", (PyCFunction) _wrap_Rect2D_MoveRightTo, METH_VARARGS | METH_KEYWORDS, NULL},
56511 { (char *)"Rect2D_GetLeftTop", (PyCFunction)_wrap_Rect2D_GetLeftTop, METH_O, NULL},
56512 { (char *)"Rect2D_SetLeftTop", (PyCFunction) _wrap_Rect2D_SetLeftTop, METH_VARARGS | METH_KEYWORDS, NULL},
56513 { (char *)"Rect2D_MoveLeftTopTo", (PyCFunction) _wrap_Rect2D_MoveLeftTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56514 { (char *)"Rect2D_GetLeftBottom", (PyCFunction)_wrap_Rect2D_GetLeftBottom, METH_O, NULL},
56515 { (char *)"Rect2D_SetLeftBottom", (PyCFunction) _wrap_Rect2D_SetLeftBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56516 { (char *)"Rect2D_MoveLeftBottomTo", (PyCFunction) _wrap_Rect2D_MoveLeftBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56517 { (char *)"Rect2D_GetRightTop", (PyCFunction)_wrap_Rect2D_GetRightTop, METH_O, NULL},
56518 { (char *)"Rect2D_SetRightTop", (PyCFunction) _wrap_Rect2D_SetRightTop, METH_VARARGS | METH_KEYWORDS, NULL},
56519 { (char *)"Rect2D_MoveRightTopTo", (PyCFunction) _wrap_Rect2D_MoveRightTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56520 { (char *)"Rect2D_GetRightBottom", (PyCFunction)_wrap_Rect2D_GetRightBottom, METH_O, NULL},
56521 { (char *)"Rect2D_SetRightBottom", (PyCFunction) _wrap_Rect2D_SetRightBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56522 { (char *)"Rect2D_MoveRightBottomTo", (PyCFunction) _wrap_Rect2D_MoveRightBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56523 { (char *)"Rect2D_GetCentre", (PyCFunction)_wrap_Rect2D_GetCentre, METH_O, NULL},
56524 { (char *)"Rect2D_SetCentre", (PyCFunction) _wrap_Rect2D_SetCentre, METH_VARARGS | METH_KEYWORDS, NULL},
56525 { (char *)"Rect2D_MoveCentreTo", (PyCFunction) _wrap_Rect2D_MoveCentreTo, METH_VARARGS | METH_KEYWORDS, NULL},
56526 { (char *)"Rect2D_GetOutcode", (PyCFunction) _wrap_Rect2D_GetOutcode, METH_VARARGS | METH_KEYWORDS, NULL},
56527 { (char *)"Rect2D_Contains", (PyCFunction) _wrap_Rect2D_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56528 { (char *)"Rect2D_ContainsRect", (PyCFunction) _wrap_Rect2D_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56529 { (char *)"Rect2D_IsEmpty", (PyCFunction)_wrap_Rect2D_IsEmpty, METH_O, NULL},
56530 { (char *)"Rect2D_HaveEqualSize", (PyCFunction) _wrap_Rect2D_HaveEqualSize, METH_VARARGS | METH_KEYWORDS, NULL},
56531 { (char *)"Rect2D_Inset", _wrap_Rect2D_Inset, METH_VARARGS, NULL},
56532 { (char *)"Rect2D_Offset", (PyCFunction) _wrap_Rect2D_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56533 { (char *)"Rect2D_ConstrainTo", (PyCFunction) _wrap_Rect2D_ConstrainTo, METH_VARARGS | METH_KEYWORDS, NULL},
56534 { (char *)"Rect2D_Interpolate", (PyCFunction) _wrap_Rect2D_Interpolate, METH_VARARGS | METH_KEYWORDS, NULL},
56535 { (char *)"Rect2D_Intersect", (PyCFunction) _wrap_Rect2D_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56536 { (char *)"Rect2D_CreateIntersection", (PyCFunction) _wrap_Rect2D_CreateIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
56537 { (char *)"Rect2D_Intersects", (PyCFunction) _wrap_Rect2D_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56538 { (char *)"Rect2D_Union", (PyCFunction) _wrap_Rect2D_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56539 { (char *)"Rect2D_CreateUnion", (PyCFunction) _wrap_Rect2D_CreateUnion, METH_VARARGS | METH_KEYWORDS, NULL},
56540 { (char *)"Rect2D_Scale", _wrap_Rect2D_Scale, METH_VARARGS, NULL},
56541 { (char *)"Rect2D___eq__", (PyCFunction) _wrap_Rect2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56542 { (char *)"Rect2D___ne__", (PyCFunction) _wrap_Rect2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56543 { (char *)"Rect2D_x_set", _wrap_Rect2D_x_set, METH_VARARGS, NULL},
56544 { (char *)"Rect2D_x_get", (PyCFunction)_wrap_Rect2D_x_get, METH_O, NULL},
56545 { (char *)"Rect2D_y_set", _wrap_Rect2D_y_set, METH_VARARGS, NULL},
56546 { (char *)"Rect2D_y_get", (PyCFunction)_wrap_Rect2D_y_get, METH_O, NULL},
56547 { (char *)"Rect2D_width_set", _wrap_Rect2D_width_set, METH_VARARGS, NULL},
56548 { (char *)"Rect2D_width_get", (PyCFunction)_wrap_Rect2D_width_get, METH_O, NULL},
56549 { (char *)"Rect2D_height_set", _wrap_Rect2D_height_set, METH_VARARGS, NULL},
56550 { (char *)"Rect2D_height_get", (PyCFunction)_wrap_Rect2D_height_get, METH_O, NULL},
56551 { (char *)"Rect2D_Set", (PyCFunction) _wrap_Rect2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56552 { (char *)"Rect2D_Get", (PyCFunction)_wrap_Rect2D_Get, METH_O, NULL},
56553 { (char *)"Rect2D_swigregister", Rect2D_swigregister, METH_VARARGS, NULL},
56554 { (char *)"Rect2D_swiginit", Rect2D_swiginit, METH_VARARGS, NULL},
56555 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
56556 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
56557 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
56558 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
56559 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
56560 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
56561 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
56562 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
56563 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
56564 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
56565 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
56566 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
56567 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
56568 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
56569 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
56570 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
56571 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
56572 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
56573 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
56574 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
56575 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
56576 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
56577 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
56578 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
56579 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
56580 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
56581 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
56582 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
56583 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
56584 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
56585 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
56586 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
56587 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
56588 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
56589 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
56590 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
56591 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56592 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56593 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56594 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56595 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
56596 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
56597 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56598 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
56599 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56600 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
56601 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
56602 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
56603 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
56604 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
56605 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
56606 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
56607 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56608 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56609 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
56610 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56611 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56612 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
56613 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
56614 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
56615 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
56616 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
56617 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
56618 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56619 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56620 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
56621 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
56622 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
56623 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56624 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56625 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56626 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
56627 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
56628 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
56629 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
56630 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56631 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
56632 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
56633 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56634 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56635 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56636 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56637 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
56638 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
56639 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
56640 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
56641 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
56642 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
56643 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
56644 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56645 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56646 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
56647 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
56648 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
56649 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
56650 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
56651 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
56652 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
56653 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
56654 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
56655 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
56656 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
56657 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56658 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
56659 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56660 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
56661 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
56662 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
56663 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
56664 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
56665 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
56666 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
56667 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
56668 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
56669 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
56670 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
56671 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
56672 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
56673 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
56674 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
56675 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
56676 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
56677 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
56678 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
56679 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
56680 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
56681 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
56682 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
56683 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
56684 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
56685 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
56686 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
56687 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56688 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
56689 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56690 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
56691 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
56692 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56693 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
56694 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
56695 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
56696 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
56697 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
56698 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
56699 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
56700 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
56701 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56702 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
56703 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
56704 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
56705 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
56706 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56707 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56708 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
56709 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
56710 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
56711 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56712 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
56713 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56714 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
56715 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56716 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
56717 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
56718 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56719 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56720 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56721 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56722 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56723 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
56724 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
56725 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
56726 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
56727 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
56728 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
56729 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56730 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
56731 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
56732 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
56733 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
56734 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
56735 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56736 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
56737 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
56738 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
56739 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56740 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
56741 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
56742 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
56743 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
56744 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
56745 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
56746 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
56747 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
56748 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
56749 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
56750 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
56751 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
56752 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
56753 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56754 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56755 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56756 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56757 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
56758 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
56759 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
56760 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56761 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56762 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56763 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
56764 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
56765 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56766 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56767 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
56768 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
56769 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56770 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
56771 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
56772 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56773 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
56774 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
56775 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
56776 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
56777 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
56778 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
56779 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
56780 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
56781 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
56782 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
56783 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
56784 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
56785 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
56786 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
56787 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
56788 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
56789 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
56790 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
56791 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
56792 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
56793 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
56794 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
56795 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
56796 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
56797 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
56798 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
56799 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
56800 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
56801 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
56802 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
56803 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
56804 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
56805 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
56806 { (char *)"new_TGAHandler", (PyCFunction)_wrap_new_TGAHandler, METH_NOARGS, NULL},
56807 { (char *)"TGAHandler_swigregister", TGAHandler_swigregister, METH_VARARGS, NULL},
56808 { (char *)"TGAHandler_swiginit", TGAHandler_swiginit, METH_VARARGS, NULL},
56809 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
56810 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
56811 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
56812 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
56813 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
56814 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56815 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56816 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
56817 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
56818 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56819 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56820 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
56821 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
56822 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
56823 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56824 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
56825 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
56826 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
56827 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
56828 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
56829 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
56830 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
56831 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
56832 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
56833 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
56834 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
56835 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
56836 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
56837 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
56838 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
56839 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
56840 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
56841 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
56842 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
56843 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
56844 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
56845 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
56846 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
56847 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
56848 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
56849 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
56850 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
56851 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
56852 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56853 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
56854 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
56855 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
56856 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
56857 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
56858 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
56859 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
56860 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
56861 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
56862 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
56863 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
56864 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
56865 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
56866 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
56867 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56868 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
56869 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
56870 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
56871 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
56872 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
56873 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56874 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
56875 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
56876 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
56877 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56878 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
56879 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
56880 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56881 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
56882 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
56883 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
56884 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56885 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
56886 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
56887 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56888 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
56889 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
56890 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
56891 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
56892 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
56893 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
56894 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
56895 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
56896 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
56897 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
56898 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
56899 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
56900 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
56901 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
56902 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
56903 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
56904 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
56905 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
56906 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
56907 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
56908 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
56909 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
56910 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
56911 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
56912 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
56913 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
56914 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
56915 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
56916 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
56917 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
56918 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56919 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
56920 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
56921 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
56922 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
56923 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
56924 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
56925 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
56926 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
56927 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
56928 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
56929 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
56930 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
56931 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
56932 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
56933 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
56934 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
56935 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
56936 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
56937 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
56938 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
56939 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
56940 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
56941 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
56942 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
56943 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
56944 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
56945 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
56946 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
56947 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
56948 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
56949 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
56950 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
56951 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56952 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
56953 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
56954 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
56955 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
56956 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
56957 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
56958 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
56959 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56960 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
56961 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
56962 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
56963 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
56964 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
56965 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
56966 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
56967 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
56968 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
56969 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
56970 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
56971 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
56972 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
56973 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
56974 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
56975 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
56976 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
56977 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
56978 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
56979 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
56980 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
56981 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
56982 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
56983 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
56984 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
56985 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
56986 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
56987 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
56988 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
56989 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
56990 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
56991 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
56992 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
56993 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
56994 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
56995 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
56996 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
56997 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
56998 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56999 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
57000 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
57001 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57002 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57003 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
57004 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
57005 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
57006 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
57007 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
57008 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
57009 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57010 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
57011 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
57012 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57013 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57014 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
57015 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
57016 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57017 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
57018 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
57019 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57020 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
57021 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
57022 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57023 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
57024 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
57025 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
57026 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57027 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
57028 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57029 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
57030 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
57031 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57032 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
57033 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
57034 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
57035 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57036 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
57037 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
57038 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
57039 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57040 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
57041 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
57042 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57043 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
57044 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
57045 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
57046 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
57047 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
57048 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57049 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
57050 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
57051 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
57052 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
57053 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
57054 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
57055 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
57056 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
57057 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57058 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
57059 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
57060 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
57061 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
57062 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57063 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
57064 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
57065 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
57066 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57067 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
57068 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
57069 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
57070 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
57071 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
57072 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
57073 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57074 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
57075 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
57076 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
57077 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
57078 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
57079 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
57080 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
57081 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
57082 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57083 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57084 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57085 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57086 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
57087 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
57088 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
57089 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
57090 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57091 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
57092 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
57093 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
57094 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
57095 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
57096 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
57097 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57098 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
57099 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
57100 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
57101 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57102 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
57103 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
57104 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
57105 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
57106 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
57107 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57108 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57109 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
57110 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
57111 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
57112 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57113 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
57114 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
57115 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
57116 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
57117 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
57118 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
57119 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57120 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
57121 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
57122 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
57123 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
57124 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
57125 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
57126 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
57127 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
57128 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
57129 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57130 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
57131 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
57132 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
57133 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57134 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
57135 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
57136 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
57137 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57138 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
57139 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57140 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
57141 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
57142 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
57143 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
57144 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
57145 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57146 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
57147 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
57148 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
57149 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
57150 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57151 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
57152 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
57153 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57154 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
57155 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57156 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
57157 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
57158 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
57159 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57160 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
57161 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57162 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
57163 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
57164 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
57165 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57166 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
57167 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
57168 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
57169 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
57170 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
57171 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
57172 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57173 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
57174 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
57175 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
57176 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
57177 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
57178 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
57179 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
57180 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
57181 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
57182 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
57183 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
57184 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
57185 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
57186 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
57187 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
57188 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
57189 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
57190 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
57191 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
57192 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
57193 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57194 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
57195 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
57196 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
57197 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
57198 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
57199 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
57200 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
57201 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
57202 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
57203 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
57204 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
57205 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
57206 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
57207 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
57208 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
57209 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57210 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57211 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57212 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
57213 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
57214 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
57215 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
57216 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
57217 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
57218 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
57219 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
57220 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
57221 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
57222 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
57223 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57224 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
57225 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
57226 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
57227 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
57228 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
57229 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
57230 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
57231 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
57232 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
57233 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
57234 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
57235 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
57236 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
57237 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
57238 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
57239 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
57240 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
57241 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
57242 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
57243 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
57244 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
57245 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57246 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57247 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
57248 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
57249 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
57250 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
57251 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
57252 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
57253 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
57254 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
57255 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57256 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
57257 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
57258 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
57259 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
57260 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
57261 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
57262 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
57263 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
57264 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
57265 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
57266 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
57267 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
57268 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
57269 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
57270 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
57271 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
57272 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
57273 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57274 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
57275 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
57276 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
57277 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
57278 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57279 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
57280 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
57281 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
57282 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
57283 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
57284 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57285 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
57286 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
57287 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57288 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57289 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
57290 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57291 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57292 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57293 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
57294 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57295 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57296 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
57297 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
57298 { (char *)"Window_SetInitialSize", (PyCFunction) _wrap_Window_SetInitialSize, METH_VARARGS | METH_KEYWORDS, NULL},
57299 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
57300 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
57301 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
57302 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57303 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
57304 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
57305 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
57306 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
57307 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
57308 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
57309 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
57310 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
57311 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
57312 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
57313 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
57314 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
57315 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
57316 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
57317 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
57318 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
57319 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
57320 { (char *)"Window_GetEffectiveMinSize", (PyCFunction)_wrap_Window_GetEffectiveMinSize, METH_O, NULL},
57321 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
57322 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
57323 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
57324 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
57325 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57326 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57327 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57328 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57329 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
57330 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
57331 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57332 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
57333 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
57334 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
57335 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
57336 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
57337 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
57338 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57339 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
57340 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
57341 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
57342 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57343 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
57344 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57345 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
57346 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
57347 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
57348 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
57349 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57350 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
57351 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57352 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
57353 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57354 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
57355 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
57356 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57357 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
57358 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
57359 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
57360 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
57361 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
57362 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
57363 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
57364 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57365 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57366 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
57367 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
57368 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
57369 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
57370 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
57371 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
57372 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
57373 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
57374 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57375 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57376 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
57377 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57378 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57379 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57380 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57381 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
57382 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
57383 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
57384 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
57385 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
57386 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
57387 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57388 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
57389 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57390 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57391 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57392 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57393 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
57394 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
57395 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57396 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57397 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
57398 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
57399 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
57400 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
57401 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
57402 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
57403 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
57404 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
57405 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
57406 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
57407 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
57408 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
57409 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
57410 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
57411 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
57412 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
57413 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
57414 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57415 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
57416 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
57417 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57418 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57419 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57420 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57421 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57422 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
57423 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
57424 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
57425 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
57426 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57427 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
57428 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
57429 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
57430 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
57431 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57432 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
57433 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
57434 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
57435 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
57436 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
57437 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
57438 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57439 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57440 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
57441 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
57442 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
57443 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
57444 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
57445 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
57446 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
57447 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
57448 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
57449 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57450 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
57451 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
57452 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
57453 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
57454 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57455 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57456 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57457 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57458 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
57459 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
57460 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57461 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
57462 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
57463 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
57464 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
57465 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
57466 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
57467 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
57468 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
57469 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57470 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
57471 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
57472 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
57473 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
57474 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
57475 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
57476 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
57477 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
57478 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
57479 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
57480 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
57481 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
57482 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57483 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
57484 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
57485 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57486 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
57487 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
57488 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
57489 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
57490 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
57491 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
57492 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
57493 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57494 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57495 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57496 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
57497 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
57498 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
57499 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
57500 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
57501 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
57502 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
57503 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
57504 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57505 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
57506 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
57507 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
57508 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
57509 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
57510 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57511 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
57512 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
57513 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
57514 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57515 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
57516 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57517 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57518 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57519 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57520 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
57521 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57522 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57523 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
57524 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57525 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
57526 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57527 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57528 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57529 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57530 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
57531 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57532 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57533 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57534 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57535 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
57536 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57537 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
57538 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
57539 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
57540 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
57541 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
57542 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
57543 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
57544 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57545 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57546 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57547 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57548 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57549 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57550 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57551 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57552 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57553 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57554 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
57555 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
57556 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57557 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
57558 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57559 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
57560 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
57561 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
57562 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
57563 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57564 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
57565 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
57566 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
57567 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
57568 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
57569 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
57570 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
57571 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57572 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57573 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
57574 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57575 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
57576 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57577 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
57578 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
57579 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57580 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57581 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57582 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57583 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57584 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57585 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57586 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57587 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57588 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57589 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57590 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57591 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57592 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
57593 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
57594 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57595 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
57596 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
57597 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57598 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
57599 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
57600 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
57601 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57602 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
57603 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
57604 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57605 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57606 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
57607 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
57608 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57609 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
57610 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
57611 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
57612 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
57613 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
57614 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
57615 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
57616 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
57617 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57618 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
57619 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57620 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
57621 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57622 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
57623 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
57624 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
57625 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
57626 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
57627 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
57628 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57629 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
57630 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57631 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
57632 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
57633 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
57634 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57635 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
57636 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
57637 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57638 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
57639 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
57640 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
57641 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
57642 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
57643 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
57644 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
57645 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
57646 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
57647 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
57648 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
57649 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57650 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
57651 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
57652 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
57653 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57654 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
57655 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
57656 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57657 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
57658 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57659 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
57660 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57661 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57662 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57663 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
57664 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
57665 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
57666 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
57667 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
57668 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
57669 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57670 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
57671 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57672 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
57673 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
57674 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
57675 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
57676 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
57677 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
57678 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57679 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57680 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57681 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
57682 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
57683 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
57684 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
57685 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57686 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
57687 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
57688 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
57689 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
57690 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
57691 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
57692 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
57693 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
57694 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
57695 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
57696 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
57697 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
57698 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
57699 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57700 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
57701 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
57702 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
57703 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
57704 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57705 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
57706 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57707 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
57708 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57709 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57710 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
57711 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
57712 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
57713 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
57714 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
57715 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
57716 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
57717 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57718 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57719 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57720 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57721 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57722 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
57723 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
57724 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57725 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
57726 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57727 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
57728 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57729 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
57730 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57731 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57732 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57733 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57734 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57735 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
57736 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
57737 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
57738 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
57739 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
57740 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
57741 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
57742 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
57743 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57744 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57745 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
57746 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
57747 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
57748 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57749 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
57750 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
57751 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
57752 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
57753 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57754 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
57755 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
57756 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57757 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
57758 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
57759 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
57760 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
57761 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57762 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
57763 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
57764 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
57765 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57766 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
57767 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
57768 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
57769 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
57770 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
57771 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
57772 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
57773 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
57774 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
57775 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
57776 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57777 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
57778 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
57779 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
57780 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
57781 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57782 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
57783 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
57784 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
57785 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
57786 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
57787 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
57788 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
57789 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
57790 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
57791 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
57792 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
57793 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
57794 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
57795 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
57796 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
57797 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
57798 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
57799 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
57800 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
57801 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
57802 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57803 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
57804 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
57805 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
57806 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
57807 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
57808 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57809 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57810 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57811 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
57812 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
57813 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
57814 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
57815 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
57816 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
57817 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
57818 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
57819 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
57820 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57821 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57822 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57823 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
57824 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
57825 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
57826 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
57827 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
57828 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57829 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57830 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57831 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
57832 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
57833 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
57834 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
57835 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
57836 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
57837 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
57838 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
57839 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57840 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
57841 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
57842 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57843 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57844 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57845 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
57846 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
57847 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
57848 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
57849 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
57850 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
57851 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
57852 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
57853 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57854 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57855 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
57856 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
57857 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
57858 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
57859 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57860 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
57861 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
57862 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
57863 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
57864 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
57865 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
57866 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
57867 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
57868 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
57869 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
57870 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
57871 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
57872 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
57873 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
57874 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
57875 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
57876 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
57877 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
57878 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
57879 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
57880 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
57881 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
57882 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
57883 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
57884 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
57885 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
57886 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
57887 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
57888 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
57889 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
57890 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
57891 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
57892 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
57893 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
57894 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
57895 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
57896 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
57897 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
57898 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
57899 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
57900 { NULL, NULL, 0, NULL }
57901 };
57902
57903
57904 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
57905
57906 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
57907 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
57908 }
57909 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
57910 return (void *)((wxSizer *) ((wxBoxSizer *) x));
57911 }
57912 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
57913 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
57914 }
57915 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
57916 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
57917 }
57918 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
57919 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
57920 }
57921 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
57922 return (void *)((wxSizer *) ((wxGridSizer *) x));
57923 }
57924 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
57925 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
57926 }
57927 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
57928 return (void *)((wxSizer *) ((wxPySizer *) x));
57929 }
57930 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
57931 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
57932 }
57933 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
57934 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
57935 }
57936 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
57937 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
57938 }
57939 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
57940 return (void *)((wxEvent *) ((wxMenuEvent *) x));
57941 }
57942 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
57943 return (void *)((wxEvent *) ((wxCloseEvent *) x));
57944 }
57945 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
57946 return (void *)((wxEvent *) ((wxMouseEvent *) x));
57947 }
57948 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
57949 return (void *)((wxEvent *) ((wxEraseEvent *) x));
57950 }
57951 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
57952 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
57953 }
57954 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
57955 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
57956 }
57957 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
57958 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
57959 }
57960 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
57961 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
57962 }
57963 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
57964 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
57965 }
57966 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
57967 return (void *)((wxEvent *) ((wxPyEvent *) x));
57968 }
57969 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
57970 return (void *)((wxEvent *) ((wxIdleEvent *) x));
57971 }
57972 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
57973 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
57974 }
57975 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
57976 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
57977 }
57978 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
57979 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
57980 }
57981 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
57982 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
57983 }
57984 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
57985 return (void *)((wxEvent *) ((wxActivateEvent *) x));
57986 }
57987 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
57988 return (void *)((wxEvent *) ((wxSizeEvent *) x));
57989 }
57990 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
57991 return (void *)((wxEvent *) ((wxMoveEvent *) x));
57992 }
57993 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
57994 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
57995 }
57996 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
57997 return (void *)((wxEvent *) ((wxPaintEvent *) x));
57998 }
57999 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
58000 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
58001 }
58002 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
58003 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
58004 }
58005 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
58006 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
58007 }
58008 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
58009 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
58010 }
58011 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
58012 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
58013 }
58014 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
58015 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58016 }
58017 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
58018 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
58019 }
58020 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
58021 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
58022 }
58023 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
58024 return (void *)((wxEvent *) ((wxFocusEvent *) x));
58025 }
58026 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
58027 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
58028 }
58029 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
58030 return (void *)((wxEvent *) ((wxShowEvent *) x));
58031 }
58032 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
58033 return (void *)((wxEvent *) ((wxCommandEvent *) x));
58034 }
58035 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
58036 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
58037 }
58038 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
58039 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58040 }
58041 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
58042 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
58043 }
58044 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
58045 return (void *)((wxEvent *) ((wxKeyEvent *) x));
58046 }
58047 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
58048 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
58049 }
58050 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
58051 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
58052 }
58053 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
58054 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
58055 }
58056 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
58057 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
58058 }
58059 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
58060 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
58061 }
58062 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
58063 return (void *)((wxControl *) ((wxControlWithItems *) x));
58064 }
58065 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
58066 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
58067 }
58068 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
58069 return (void *)((wxEvtHandler *) ((wxWindow *) x));
58070 }
58071 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
58072 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58073 }
58074 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
58075 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
58076 }
58077 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
58078 return (void *)((wxEvtHandler *) ((wxValidator *) x));
58079 }
58080 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
58081 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
58082 }
58083 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
58084 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
58085 }
58086 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
58087 return (void *)((wxEvtHandler *) ((wxMenu *) x));
58088 }
58089 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
58090 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
58091 }
58092 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
58093 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
58094 }
58095 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
58096 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
58097 }
58098 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
58099 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
58100 }
58101 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
58102 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
58103 }
58104 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
58105 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58106 }
58107 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
58108 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
58109 }
58110 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
58111 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
58112 }
58113 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
58114 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
58115 }
58116 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
58117 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58118 }
58119 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
58120 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58121 }
58122 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
58123 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
58124 }
58125 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
58126 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
58127 }
58128 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
58129 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
58130 }
58131 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
58132 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
58133 }
58134 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
58135 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
58136 }
58137 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
58138 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
58139 }
58140 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
58141 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
58142 }
58143 static void *_p_wxTGAHandlerTo_p_wxImageHandler(void *x) {
58144 return (void *)((wxImageHandler *) ((wxTGAHandler *) x));
58145 }
58146 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
58147 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
58148 }
58149 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
58150 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
58151 }
58152 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
58153 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
58154 }
58155 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
58156 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
58157 }
58158 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
58159 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
58160 }
58161 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
58162 return (void *)((wxObject *) ((wxSizerItem *) x));
58163 }
58164 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
58165 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
58166 }
58167 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
58168 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
58169 }
58170 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
58171 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
58172 }
58173 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
58174 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
58175 }
58176 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
58177 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
58178 }
58179 static void *_p_wxSizerTo_p_wxObject(void *x) {
58180 return (void *)((wxObject *) ((wxSizer *) x));
58181 }
58182 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
58183 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
58184 }
58185 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
58186 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
58187 }
58188 static void *_p_wxEventTo_p_wxObject(void *x) {
58189 return (void *)((wxObject *) ((wxEvent *) x));
58190 }
58191 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
58192 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
58193 }
58194 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
58195 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
58196 }
58197 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
58198 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
58199 }
58200 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
58201 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
58202 }
58203 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
58204 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
58205 }
58206 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
58207 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
58208 }
58209 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
58210 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
58211 }
58212 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
58213 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
58214 }
58215 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
58216 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58217 }
58218 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
58219 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
58220 }
58221 static void *_p_wxControlTo_p_wxObject(void *x) {
58222 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
58223 }
58224 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
58225 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
58226 }
58227 static void *_p_wxFSFileTo_p_wxObject(void *x) {
58228 return (void *)((wxObject *) ((wxFSFile *) x));
58229 }
58230 static void *_p_wxPySizerTo_p_wxObject(void *x) {
58231 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
58232 }
58233 static void *_p_wxPyEventTo_p_wxObject(void *x) {
58234 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
58235 }
58236 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
58237 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
58238 }
58239 static void *_p_wxShowEventTo_p_wxObject(void *x) {
58240 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
58241 }
58242 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
58243 return (void *)((wxObject *) ((wxMenuItem *) x));
58244 }
58245 static void *_p_wxDateEventTo_p_wxObject(void *x) {
58246 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
58247 }
58248 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
58249 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
58250 }
58251 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
58252 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
58253 }
58254 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
58255 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
58256 }
58257 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
58258 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
58259 }
58260 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
58261 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
58262 }
58263 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
58264 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
58265 }
58266 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
58267 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
58268 }
58269 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
58270 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
58271 }
58272 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
58273 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
58274 }
58275 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
58276 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
58277 }
58278 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
58279 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
58280 }
58281 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
58282 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
58283 }
58284 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
58285 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
58286 }
58287 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
58288 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58289 }
58290 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
58291 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58292 }
58293 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
58294 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
58295 }
58296 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
58297 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
58298 }
58299 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
58300 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
58301 }
58302 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
58303 return (void *)((wxObject *) ((wxImageHandler *) x));
58304 }
58305 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
58306 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
58307 }
58308 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
58309 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
58310 }
58311 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
58312 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
58313 }
58314 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
58315 return (void *)((wxObject *) ((wxEvtHandler *) x));
58316 }
58317 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
58318 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
58319 }
58320 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
58321 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
58322 }
58323 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
58324 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58325 }
58326 static void *_p_wxImageTo_p_wxObject(void *x) {
58327 return (void *)((wxObject *) ((wxImage *) x));
58328 }
58329 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
58330 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
58331 }
58332 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
58333 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58334 }
58335 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
58336 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
58337 }
58338 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
58339 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
58340 }
58341 static void *_p_wxWindowTo_p_wxObject(void *x) {
58342 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
58343 }
58344 static void *_p_wxMenuTo_p_wxObject(void *x) {
58345 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
58346 }
58347 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
58348 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
58349 }
58350 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
58351 return (void *)((wxObject *) ((wxFileSystem *) x));
58352 }
58353 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
58354 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
58355 }
58356 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
58357 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
58358 }
58359 static void *_p_wxPyAppTo_p_wxObject(void *x) {
58360 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
58361 }
58362 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
58363 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
58364 }
58365 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
58366 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
58367 }
58368 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
58369 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
58370 }
58371 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
58372 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
58373 }
58374 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
58375 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
58376 }
58377 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
58378 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
58379 }
58380 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
58381 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
58382 }
58383 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
58384 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
58385 }
58386 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
58387 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58388 }
58389 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
58390 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
58391 }
58392 static void *_p_wxValidatorTo_p_wxObject(void *x) {
58393 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
58394 }
58395 static void *_p_wxControlTo_p_wxWindow(void *x) {
58396 return (void *)((wxWindow *) ((wxControl *) x));
58397 }
58398 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
58399 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
58400 }
58401 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
58402 return (void *)((wxWindow *) ((wxMenuBar *) x));
58403 }
58404 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
58405 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
58406 }
58407 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
58408 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
58409 }
58410 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
58411 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
58412 }
58413 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
58414 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
58415 }
58416 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
58417 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
58418 }
58419 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
58420 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
58421 }
58422 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
58423 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58424 }
58425 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
58426 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
58427 }
58428 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
58429 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
58430 }
58431 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
58432 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
58433 }
58434 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
58435 return (void *)((wxValidator *) ((wxPyValidator *) x));
58436 }
58437 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
58438 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
58439 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};
58440 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
58441 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
58442 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
58443 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
58444 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
58445 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
58446 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
58447 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
58448 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
58449 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
58450 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
58451 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
58452 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
58453 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
58454 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
58455 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
58456 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
58457 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
58458 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
58459 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
58460 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
58461 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
58462 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
58463 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
58464 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
58465 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
58466 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
58467 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
58468 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
58469 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
58470 static swig_type_info _swigt__p_wxDouble = {"_p_wxDouble", "wxDouble *", 0, 0, (void*)0, 0};
58471 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
58472 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
58473 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
58474 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
58475 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
58476 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
58477 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
58478 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
58479 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
58480 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
58481 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
58482 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
58483 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
58484 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
58485 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
58486 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
58487 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
58488 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
58489 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
58490 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
58491 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
58492 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
58493 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
58494 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
58495 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
58496 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
58497 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
58498 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
58499 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
58500 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
58501 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
58502 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
58503 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
58504 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
58505 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
58506 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
58507 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
58508 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
58509 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
58510 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
58511 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
58512 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
58513 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
58514 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
58515 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
58516 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
58517 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
58518 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
58519 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
58520 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
58521 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
58522 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
58523 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
58524 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
58525 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
58526 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
58527 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
58528 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
58529 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
58530 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
58531 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
58532 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
58533 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
58534 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
58535 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
58536 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
58537 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
58538 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
58539 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
58540 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
58541 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
58542 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
58543 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
58544 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
58545 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
58546 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
58547 static swig_type_info _swigt__p_wxRect2D = {"_p_wxRect2D", "wxRect2D *", 0, 0, (void*)0, 0};
58548 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
58549 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
58550 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
58551 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
58552 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
58553 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
58554 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
58555 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
58556 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
58557 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
58558 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
58559 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
58560 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
58561 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", "wxTGAHandler *", 0, 0, (void*)0, 0};
58562 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
58563 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
58564 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
58565 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
58566 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
58567 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
58568 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
58569 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
58570 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
58571 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
58572
58573 static swig_type_info *swig_type_initial[] = {
58574 &_swigt__p_buffer,
58575 &_swigt__p_char,
58576 &_swigt__p_form_ops_t,
58577 &_swigt__p_int,
58578 &_swigt__p_long,
58579 &_swigt__p_unsigned_char,
58580 &_swigt__p_unsigned_int,
58581 &_swigt__p_unsigned_long,
58582 &_swigt__p_wxANIHandler,
58583 &_swigt__p_wxAcceleratorEntry,
58584 &_swigt__p_wxAcceleratorTable,
58585 &_swigt__p_wxActivateEvent,
58586 &_swigt__p_wxAppTraits,
58587 &_swigt__p_wxArrayString,
58588 &_swigt__p_wxBMPHandler,
58589 &_swigt__p_wxBitmap,
58590 &_swigt__p_wxBoxSizer,
58591 &_swigt__p_wxButton,
58592 &_swigt__p_wxCURHandler,
58593 &_swigt__p_wxCaret,
58594 &_swigt__p_wxChildFocusEvent,
58595 &_swigt__p_wxClipboardTextEvent,
58596 &_swigt__p_wxCloseEvent,
58597 &_swigt__p_wxColour,
58598 &_swigt__p_wxCommandEvent,
58599 &_swigt__p_wxContextMenuEvent,
58600 &_swigt__p_wxControl,
58601 &_swigt__p_wxControlWithItems,
58602 &_swigt__p_wxCursor,
58603 &_swigt__p_wxDC,
58604 &_swigt__p_wxDateEvent,
58605 &_swigt__p_wxDateTime,
58606 &_swigt__p_wxDisplayChangedEvent,
58607 &_swigt__p_wxDouble,
58608 &_swigt__p_wxDropFilesEvent,
58609 &_swigt__p_wxDuplexMode,
58610 &_swigt__p_wxEraseEvent,
58611 &_swigt__p_wxEvent,
58612 &_swigt__p_wxEventLoop,
58613 &_swigt__p_wxEventLoopActivator,
58614 &_swigt__p_wxEvtHandler,
58615 &_swigt__p_wxFSFile,
58616 &_swigt__p_wxFileSystem,
58617 &_swigt__p_wxFileSystemHandler,
58618 &_swigt__p_wxFlexGridSizer,
58619 &_swigt__p_wxFocusEvent,
58620 &_swigt__p_wxFont,
58621 &_swigt__p_wxFrame,
58622 &_swigt__p_wxGBPosition,
58623 &_swigt__p_wxGBSizerItem,
58624 &_swigt__p_wxGBSpan,
58625 &_swigt__p_wxGIFHandler,
58626 &_swigt__p_wxGridBagSizer,
58627 &_swigt__p_wxGridSizer,
58628 &_swigt__p_wxHelpEvent__Origin,
58629 &_swigt__p_wxICOHandler,
58630 &_swigt__p_wxIconizeEvent,
58631 &_swigt__p_wxIdleEvent,
58632 &_swigt__p_wxImage,
58633 &_swigt__p_wxImageHandler,
58634 &_swigt__p_wxImageHistogram,
58635 &_swigt__p_wxImage_HSVValue,
58636 &_swigt__p_wxImage_RGBValue,
58637 &_swigt__p_wxIndividualLayoutConstraint,
58638 &_swigt__p_wxInitDialogEvent,
58639 &_swigt__p_wxInputStream,
58640 &_swigt__p_wxInternetFSHandler,
58641 &_swigt__p_wxItemContainer,
58642 &_swigt__p_wxJPEGHandler,
58643 &_swigt__p_wxKeyEvent,
58644 &_swigt__p_wxLayoutConstraints,
58645 &_swigt__p_wxMaximizeEvent,
58646 &_swigt__p_wxMemoryFSHandler,
58647 &_swigt__p_wxMenu,
58648 &_swigt__p_wxMenuBar,
58649 &_swigt__p_wxMenuBarBase,
58650 &_swigt__p_wxMenuEvent,
58651 &_swigt__p_wxMenuItem,
58652 &_swigt__p_wxMouseCaptureChangedEvent,
58653 &_swigt__p_wxMouseCaptureLostEvent,
58654 &_swigt__p_wxMouseEvent,
58655 &_swigt__p_wxMoveEvent,
58656 &_swigt__p_wxNavigationKeyEvent,
58657 &_swigt__p_wxNcPaintEvent,
58658 &_swigt__p_wxNotifyEvent,
58659 &_swigt__p_wxObject,
58660 &_swigt__p_wxOutputStream,
58661 &_swigt__p_wxPCXHandler,
58662 &_swigt__p_wxPNGHandler,
58663 &_swigt__p_wxPNMHandler,
58664 &_swigt__p_wxPaintEvent,
58665 &_swigt__p_wxPaletteChangedEvent,
58666 &_swigt__p_wxPaperSize,
58667 &_swigt__p_wxPoint,
58668 &_swigt__p_wxPoint2D,
58669 &_swigt__p_wxPropagateOnce,
58670 &_swigt__p_wxPropagationDisabler,
58671 &_swigt__p_wxPyApp,
58672 &_swigt__p_wxPyCommandEvent,
58673 &_swigt__p_wxPyDropTarget,
58674 &_swigt__p_wxPyEvent,
58675 &_swigt__p_wxPyFileSystemHandler,
58676 &_swigt__p_wxPyImageHandler,
58677 &_swigt__p_wxPyInputStream,
58678 &_swigt__p_wxPySizer,
58679 &_swigt__p_wxPyValidator,
58680 &_swigt__p_wxQuantize,
58681 &_swigt__p_wxQueryNewPaletteEvent,
58682 &_swigt__p_wxRealPoint,
58683 &_swigt__p_wxRect,
58684 &_swigt__p_wxRect2D,
58685 &_swigt__p_wxRegion,
58686 &_swigt__p_wxScrollEvent,
58687 &_swigt__p_wxScrollWinEvent,
58688 &_swigt__p_wxSetCursorEvent,
58689 &_swigt__p_wxShowEvent,
58690 &_swigt__p_wxSize,
58691 &_swigt__p_wxSizeEvent,
58692 &_swigt__p_wxSizer,
58693 &_swigt__p_wxSizerItem,
58694 &_swigt__p_wxStaticBox,
58695 &_swigt__p_wxStaticBoxSizer,
58696 &_swigt__p_wxStdDialogButtonSizer,
58697 &_swigt__p_wxSysColourChangedEvent,
58698 &_swigt__p_wxTGAHandler,
58699 &_swigt__p_wxTIFFHandler,
58700 &_swigt__p_wxToolTip,
58701 &_swigt__p_wxUpdateUIEvent,
58702 &_swigt__p_wxValidator,
58703 &_swigt__p_wxVisualAttributes,
58704 &_swigt__p_wxWindow,
58705 &_swigt__p_wxWindowCreateEvent,
58706 &_swigt__p_wxWindowDestroyEvent,
58707 &_swigt__p_wxXPMHandler,
58708 &_swigt__p_wxZipFSHandler,
58709 };
58710
58711 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
58712 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
58713 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
58714 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
58715 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
58716 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
58717 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
58718 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
58719 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
58720 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
58721 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
58722 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
58723 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
58724 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
58725 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}};
58726 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
58727 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}};
58728 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
58729 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}};
58730 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
58731 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58732 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
58733 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
58734 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
58735 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}};
58736 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
58737 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}};
58738 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
58739 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
58740 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
58741 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
58742 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
58743 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58744 static swig_cast_info _swigc__p_wxDouble[] = { {&_swigt__p_wxDouble, 0, 0, 0},{0, 0, 0, 0}};
58745 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
58746 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
58747 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
58748 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}};
58749 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
58750 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
58751 static swig_cast_info _swigc__p_wxEvtHandler[] = { {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEvtHandler, 0, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
58752 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
58753 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
58754 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}};
58755 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}};
58756 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58757 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
58758 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
58759 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
58760 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
58761 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
58762 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
58763 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
58764 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}};
58765 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
58766 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}};
58767 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58768 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
58769 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
58770 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}};
58771 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
58772 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
58773 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
58774 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
58775 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
58776 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
58777 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58778 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}};
58779 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
58780 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
58781 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
58782 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58783 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58784 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
58785 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
58786 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
58787 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
58788 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
58789 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58790 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
58791 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
58792 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
58793 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
58794 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
58795 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
58796 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_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_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}};
58797 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
58798 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
58799 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
58800 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
58801 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
58802 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58803 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
58804 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
58805 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
58806 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
58807 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
58808 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
58809 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
58810 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
58811 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
58812 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
58813 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
58814 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
58815 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
58816 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
58817 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
58818 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
58819 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
58820 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
58821 static swig_cast_info _swigc__p_wxRect2D[] = { {&_swigt__p_wxRect2D, 0, 0, 0},{0, 0, 0, 0}};
58822 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
58823 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
58824 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
58825 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
58826 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
58827 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
58828 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58829 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}};
58830 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}};
58831 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
58832 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
58833 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
58834 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58835 static swig_cast_info _swigc__p_wxTGAHandler[] = { {&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
58836 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
58837 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
58838 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
58839 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}};
58840 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
58841 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}};
58842 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
58843 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
58844 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
58845 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58846
58847 static swig_cast_info *swig_cast_initial[] = {
58848 _swigc__p_buffer,
58849 _swigc__p_char,
58850 _swigc__p_form_ops_t,
58851 _swigc__p_int,
58852 _swigc__p_long,
58853 _swigc__p_unsigned_char,
58854 _swigc__p_unsigned_int,
58855 _swigc__p_unsigned_long,
58856 _swigc__p_wxANIHandler,
58857 _swigc__p_wxAcceleratorEntry,
58858 _swigc__p_wxAcceleratorTable,
58859 _swigc__p_wxActivateEvent,
58860 _swigc__p_wxAppTraits,
58861 _swigc__p_wxArrayString,
58862 _swigc__p_wxBMPHandler,
58863 _swigc__p_wxBitmap,
58864 _swigc__p_wxBoxSizer,
58865 _swigc__p_wxButton,
58866 _swigc__p_wxCURHandler,
58867 _swigc__p_wxCaret,
58868 _swigc__p_wxChildFocusEvent,
58869 _swigc__p_wxClipboardTextEvent,
58870 _swigc__p_wxCloseEvent,
58871 _swigc__p_wxColour,
58872 _swigc__p_wxCommandEvent,
58873 _swigc__p_wxContextMenuEvent,
58874 _swigc__p_wxControl,
58875 _swigc__p_wxControlWithItems,
58876 _swigc__p_wxCursor,
58877 _swigc__p_wxDC,
58878 _swigc__p_wxDateEvent,
58879 _swigc__p_wxDateTime,
58880 _swigc__p_wxDisplayChangedEvent,
58881 _swigc__p_wxDouble,
58882 _swigc__p_wxDropFilesEvent,
58883 _swigc__p_wxDuplexMode,
58884 _swigc__p_wxEraseEvent,
58885 _swigc__p_wxEvent,
58886 _swigc__p_wxEventLoop,
58887 _swigc__p_wxEventLoopActivator,
58888 _swigc__p_wxEvtHandler,
58889 _swigc__p_wxFSFile,
58890 _swigc__p_wxFileSystem,
58891 _swigc__p_wxFileSystemHandler,
58892 _swigc__p_wxFlexGridSizer,
58893 _swigc__p_wxFocusEvent,
58894 _swigc__p_wxFont,
58895 _swigc__p_wxFrame,
58896 _swigc__p_wxGBPosition,
58897 _swigc__p_wxGBSizerItem,
58898 _swigc__p_wxGBSpan,
58899 _swigc__p_wxGIFHandler,
58900 _swigc__p_wxGridBagSizer,
58901 _swigc__p_wxGridSizer,
58902 _swigc__p_wxHelpEvent__Origin,
58903 _swigc__p_wxICOHandler,
58904 _swigc__p_wxIconizeEvent,
58905 _swigc__p_wxIdleEvent,
58906 _swigc__p_wxImage,
58907 _swigc__p_wxImageHandler,
58908 _swigc__p_wxImageHistogram,
58909 _swigc__p_wxImage_HSVValue,
58910 _swigc__p_wxImage_RGBValue,
58911 _swigc__p_wxIndividualLayoutConstraint,
58912 _swigc__p_wxInitDialogEvent,
58913 _swigc__p_wxInputStream,
58914 _swigc__p_wxInternetFSHandler,
58915 _swigc__p_wxItemContainer,
58916 _swigc__p_wxJPEGHandler,
58917 _swigc__p_wxKeyEvent,
58918 _swigc__p_wxLayoutConstraints,
58919 _swigc__p_wxMaximizeEvent,
58920 _swigc__p_wxMemoryFSHandler,
58921 _swigc__p_wxMenu,
58922 _swigc__p_wxMenuBar,
58923 _swigc__p_wxMenuBarBase,
58924 _swigc__p_wxMenuEvent,
58925 _swigc__p_wxMenuItem,
58926 _swigc__p_wxMouseCaptureChangedEvent,
58927 _swigc__p_wxMouseCaptureLostEvent,
58928 _swigc__p_wxMouseEvent,
58929 _swigc__p_wxMoveEvent,
58930 _swigc__p_wxNavigationKeyEvent,
58931 _swigc__p_wxNcPaintEvent,
58932 _swigc__p_wxNotifyEvent,
58933 _swigc__p_wxObject,
58934 _swigc__p_wxOutputStream,
58935 _swigc__p_wxPCXHandler,
58936 _swigc__p_wxPNGHandler,
58937 _swigc__p_wxPNMHandler,
58938 _swigc__p_wxPaintEvent,
58939 _swigc__p_wxPaletteChangedEvent,
58940 _swigc__p_wxPaperSize,
58941 _swigc__p_wxPoint,
58942 _swigc__p_wxPoint2D,
58943 _swigc__p_wxPropagateOnce,
58944 _swigc__p_wxPropagationDisabler,
58945 _swigc__p_wxPyApp,
58946 _swigc__p_wxPyCommandEvent,
58947 _swigc__p_wxPyDropTarget,
58948 _swigc__p_wxPyEvent,
58949 _swigc__p_wxPyFileSystemHandler,
58950 _swigc__p_wxPyImageHandler,
58951 _swigc__p_wxPyInputStream,
58952 _swigc__p_wxPySizer,
58953 _swigc__p_wxPyValidator,
58954 _swigc__p_wxQuantize,
58955 _swigc__p_wxQueryNewPaletteEvent,
58956 _swigc__p_wxRealPoint,
58957 _swigc__p_wxRect,
58958 _swigc__p_wxRect2D,
58959 _swigc__p_wxRegion,
58960 _swigc__p_wxScrollEvent,
58961 _swigc__p_wxScrollWinEvent,
58962 _swigc__p_wxSetCursorEvent,
58963 _swigc__p_wxShowEvent,
58964 _swigc__p_wxSize,
58965 _swigc__p_wxSizeEvent,
58966 _swigc__p_wxSizer,
58967 _swigc__p_wxSizerItem,
58968 _swigc__p_wxStaticBox,
58969 _swigc__p_wxStaticBoxSizer,
58970 _swigc__p_wxStdDialogButtonSizer,
58971 _swigc__p_wxSysColourChangedEvent,
58972 _swigc__p_wxTGAHandler,
58973 _swigc__p_wxTIFFHandler,
58974 _swigc__p_wxToolTip,
58975 _swigc__p_wxUpdateUIEvent,
58976 _swigc__p_wxValidator,
58977 _swigc__p_wxVisualAttributes,
58978 _swigc__p_wxWindow,
58979 _swigc__p_wxWindowCreateEvent,
58980 _swigc__p_wxWindowDestroyEvent,
58981 _swigc__p_wxXPMHandler,
58982 _swigc__p_wxZipFSHandler,
58983 };
58984
58985
58986 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
58987
58988 static swig_const_info swig_const_table[] = {
58989 {0, 0, 0, 0.0, 0, 0}};
58990
58991 #ifdef __cplusplus
58992 }
58993 #endif
58994 /* -----------------------------------------------------------------------------
58995 * Type initialization:
58996 * This problem is tough by the requirement that no dynamic
58997 * memory is used. Also, since swig_type_info structures store pointers to
58998 * swig_cast_info structures and swig_cast_info structures store pointers back
58999 * to swig_type_info structures, we need some lookup code at initialization.
59000 * The idea is that swig generates all the structures that are needed.
59001 * The runtime then collects these partially filled structures.
59002 * The SWIG_InitializeModule function takes these initial arrays out of
59003 * swig_module, and does all the lookup, filling in the swig_module.types
59004 * array with the correct data and linking the correct swig_cast_info
59005 * structures together.
59006 *
59007 * The generated swig_type_info structures are assigned staticly to an initial
59008 * array. We just loop though that array, and handle each type individually.
59009 * First we lookup if this type has been already loaded, and if so, use the
59010 * loaded structure instead of the generated one. Then we have to fill in the
59011 * cast linked list. The cast data is initially stored in something like a
59012 * two-dimensional array. Each row corresponds to a type (there are the same
59013 * number of rows as there are in the swig_type_initial array). Each entry in
59014 * a column is one of the swig_cast_info structures for that type.
59015 * The cast_initial array is actually an array of arrays, because each row has
59016 * a variable number of columns. So to actually build the cast linked list,
59017 * we find the array of casts associated with the type, and loop through it
59018 * adding the casts to the list. The one last trick we need to do is making
59019 * sure the type pointer in the swig_cast_info struct is correct.
59020 *
59021 * First off, we lookup the cast->type name to see if it is already loaded.
59022 * There are three cases to handle:
59023 * 1) If the cast->type has already been loaded AND the type we are adding
59024 * casting info to has not been loaded (it is in this module), THEN we
59025 * replace the cast->type pointer with the type pointer that has already
59026 * been loaded.
59027 * 2) If BOTH types (the one we are adding casting info to, and the
59028 * cast->type) are loaded, THEN the cast info has already been loaded by
59029 * the previous module so we just ignore it.
59030 * 3) Finally, if cast->type has not already been loaded, then we add that
59031 * swig_cast_info to the linked list (because the cast->type) pointer will
59032 * be correct.
59033 * ----------------------------------------------------------------------------- */
59034
59035 #ifdef __cplusplus
59036 extern "C" {
59037 #if 0
59038 } /* c-mode */
59039 #endif
59040 #endif
59041
59042 #if 0
59043 #define SWIGRUNTIME_DEBUG
59044 #endif
59045
59046 SWIGRUNTIME void
59047 SWIG_InitializeModule(void *clientdata) {
59048 size_t i;
59049 swig_module_info *module_head;
59050 static int init_run = 0;
59051
59052 clientdata = clientdata;
59053
59054 if (init_run) return;
59055 init_run = 1;
59056
59057 /* Initialize the swig_module */
59058 swig_module.type_initial = swig_type_initial;
59059 swig_module.cast_initial = swig_cast_initial;
59060
59061 /* Try and load any already created modules */
59062 module_head = SWIG_GetModule(clientdata);
59063 if (module_head) {
59064 swig_module.next = module_head->next;
59065 module_head->next = &swig_module;
59066 } else {
59067 /* This is the first module loaded */
59068 swig_module.next = &swig_module;
59069 SWIG_SetModule(clientdata, &swig_module);
59070 }
59071
59072 /* Now work on filling in swig_module.types */
59073 #ifdef SWIGRUNTIME_DEBUG
59074 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
59075 #endif
59076 for (i = 0; i < swig_module.size; ++i) {
59077 swig_type_info *type = 0;
59078 swig_type_info *ret;
59079 swig_cast_info *cast;
59080
59081 #ifdef SWIGRUNTIME_DEBUG
59082 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59083 #endif
59084
59085 /* if there is another module already loaded */
59086 if (swig_module.next != &swig_module) {
59087 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
59088 }
59089 if (type) {
59090 /* Overwrite clientdata field */
59091 #ifdef SWIGRUNTIME_DEBUG
59092 printf("SWIG_InitializeModule: found type %s\n", type->name);
59093 #endif
59094 if (swig_module.type_initial[i]->clientdata) {
59095 type->clientdata = swig_module.type_initial[i]->clientdata;
59096 #ifdef SWIGRUNTIME_DEBUG
59097 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
59098 #endif
59099 }
59100 } else {
59101 type = swig_module.type_initial[i];
59102 }
59103
59104 /* Insert casting types */
59105 cast = swig_module.cast_initial[i];
59106 while (cast->type) {
59107 /* Don't need to add information already in the list */
59108 ret = 0;
59109 #ifdef SWIGRUNTIME_DEBUG
59110 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
59111 #endif
59112 if (swig_module.next != &swig_module) {
59113 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
59114 #ifdef SWIGRUNTIME_DEBUG
59115 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
59116 #endif
59117 }
59118 if (ret) {
59119 if (type == swig_module.type_initial[i]) {
59120 #ifdef SWIGRUNTIME_DEBUG
59121 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
59122 #endif
59123 cast->type = ret;
59124 ret = 0;
59125 } else {
59126 /* Check for casting already in the list */
59127 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
59128 #ifdef SWIGRUNTIME_DEBUG
59129 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
59130 #endif
59131 if (!ocast) ret = 0;
59132 }
59133 }
59134
59135 if (!ret) {
59136 #ifdef SWIGRUNTIME_DEBUG
59137 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
59138 #endif
59139 if (type->cast) {
59140 type->cast->prev = cast;
59141 cast->next = type->cast;
59142 }
59143 type->cast = cast;
59144 }
59145 cast++;
59146 }
59147 /* Set entry in modules->types array equal to the type */
59148 swig_module.types[i] = type;
59149 }
59150 swig_module.types[i] = 0;
59151
59152 #ifdef SWIGRUNTIME_DEBUG
59153 printf("**** SWIG_InitializeModule: Cast List ******\n");
59154 for (i = 0; i < swig_module.size; ++i) {
59155 int j = 0;
59156 swig_cast_info *cast = swig_module.cast_initial[i];
59157 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59158 while (cast->type) {
59159 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
59160 cast++;
59161 ++j;
59162 }
59163 printf("---- Total casts: %d\n",j);
59164 }
59165 printf("**** SWIG_InitializeModule: Cast List ******\n");
59166 #endif
59167 }
59168
59169 /* This function will propagate the clientdata field of type to
59170 * any new swig_type_info structures that have been added into the list
59171 * of equivalent types. It is like calling
59172 * SWIG_TypeClientData(type, clientdata) a second time.
59173 */
59174 SWIGRUNTIME void
59175 SWIG_PropagateClientData(void) {
59176 size_t i;
59177 swig_cast_info *equiv;
59178 static int init_run = 0;
59179
59180 if (init_run) return;
59181 init_run = 1;
59182
59183 for (i = 0; i < swig_module.size; i++) {
59184 if (swig_module.types[i]->clientdata) {
59185 equiv = swig_module.types[i]->cast;
59186 while (equiv) {
59187 if (!equiv->converter) {
59188 if (equiv->type && !equiv->type->clientdata)
59189 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
59190 }
59191 equiv = equiv->next;
59192 }
59193 }
59194 }
59195 }
59196
59197 #ifdef __cplusplus
59198 #if 0
59199 {
59200 /* c-mode */
59201 #endif
59202 }
59203 #endif
59204
59205
59206
59207 #ifdef __cplusplus
59208 extern "C" {
59209 #endif
59210
59211 /* Python-specific SWIG API */
59212 #define SWIG_newvarlink() SWIG_Python_newvarlink()
59213 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
59214 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
59215
59216 /* -----------------------------------------------------------------------------
59217 * global variable support code.
59218 * ----------------------------------------------------------------------------- */
59219
59220 typedef struct swig_globalvar {
59221 char *name; /* Name of global variable */
59222 PyObject *(*get_attr)(void); /* Return the current value */
59223 int (*set_attr)(PyObject *); /* Set the value */
59224 struct swig_globalvar *next;
59225 } swig_globalvar;
59226
59227 typedef struct swig_varlinkobject {
59228 PyObject_HEAD
59229 swig_globalvar *vars;
59230 } swig_varlinkobject;
59231
59232 SWIGINTERN PyObject *
59233 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
59234 return PyString_FromString("<Swig global variables>");
59235 }
59236
59237 SWIGINTERN PyObject *
59238 swig_varlink_str(swig_varlinkobject *v) {
59239 PyObject *str = PyString_FromString("(");
59240 swig_globalvar *var;
59241 for (var = v->vars; var; var=var->next) {
59242 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
59243 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
59244 }
59245 PyString_ConcatAndDel(&str,PyString_FromString(")"));
59246 return str;
59247 }
59248
59249 SWIGINTERN int
59250 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
59251 PyObject *str = swig_varlink_str(v);
59252 fprintf(fp,"Swig global variables ");
59253 fprintf(fp,"%s\n", PyString_AsString(str));
59254 Py_DECREF(str);
59255 return 0;
59256 }
59257
59258 SWIGINTERN void
59259 swig_varlink_dealloc(swig_varlinkobject *v) {
59260 swig_globalvar *var = v->vars;
59261 while (var) {
59262 swig_globalvar *n = var->next;
59263 free(var->name);
59264 free(var);
59265 var = n;
59266 }
59267 }
59268
59269 SWIGINTERN PyObject *
59270 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
59271 PyObject *res = NULL;
59272 swig_globalvar *var = v->vars;
59273 while (var) {
59274 if (strcmp(var->name,n) == 0) {
59275 res = (*var->get_attr)();
59276 break;
59277 }
59278 var = var->next;
59279 }
59280 if (res == NULL && !PyErr_Occurred()) {
59281 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59282 }
59283 return res;
59284 }
59285
59286 SWIGINTERN int
59287 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
59288 int res = 1;
59289 swig_globalvar *var = v->vars;
59290 while (var) {
59291 if (strcmp(var->name,n) == 0) {
59292 res = (*var->set_attr)(p);
59293 break;
59294 }
59295 var = var->next;
59296 }
59297 if (res == 1 && !PyErr_Occurred()) {
59298 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59299 }
59300 return res;
59301 }
59302
59303 SWIGINTERN PyTypeObject*
59304 swig_varlink_type(void) {
59305 static char varlink__doc__[] = "Swig var link object";
59306 static PyTypeObject varlink_type;
59307 static int type_init = 0;
59308 if (!type_init) {
59309 const PyTypeObject tmp
59310 = {
59311 PyObject_HEAD_INIT(NULL)
59312 0, /* Number of items in variable part (ob_size) */
59313 (char *)"swigvarlink", /* Type name (tp_name) */
59314 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
59315 0, /* Itemsize (tp_itemsize) */
59316 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
59317 (printfunc) swig_varlink_print, /* Print (tp_print) */
59318 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
59319 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
59320 0, /* tp_compare */
59321 (reprfunc) swig_varlink_repr, /* tp_repr */
59322 0, /* tp_as_number */
59323 0, /* tp_as_sequence */
59324 0, /* tp_as_mapping */
59325 0, /* tp_hash */
59326 0, /* tp_call */
59327 (reprfunc)swig_varlink_str, /* tp_str */
59328 0, /* tp_getattro */
59329 0, /* tp_setattro */
59330 0, /* tp_as_buffer */
59331 0, /* tp_flags */
59332 varlink__doc__, /* tp_doc */
59333 0, /* tp_traverse */
59334 0, /* tp_clear */
59335 0, /* tp_richcompare */
59336 0, /* tp_weaklistoffset */
59337 #if PY_VERSION_HEX >= 0x02020000
59338 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
59339 #endif
59340 #if PY_VERSION_HEX >= 0x02030000
59341 0, /* tp_del */
59342 #endif
59343 #ifdef COUNT_ALLOCS
59344 0,0,0,0 /* tp_alloc -> tp_next */
59345 #endif
59346 };
59347 varlink_type = tmp;
59348 varlink_type.ob_type = &PyType_Type;
59349 type_init = 1;
59350 }
59351 return &varlink_type;
59352 }
59353
59354 /* Create a variable linking object for use later */
59355 SWIGINTERN PyObject *
59356 SWIG_Python_newvarlink(void) {
59357 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
59358 if (result) {
59359 result->vars = 0;
59360 }
59361 return ((PyObject*) result);
59362 }
59363
59364 SWIGINTERN void
59365 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
59366 swig_varlinkobject *v = (swig_varlinkobject *) p;
59367 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
59368 if (gv) {
59369 size_t size = strlen(name)+1;
59370 gv->name = (char *)malloc(size);
59371 if (gv->name) {
59372 strncpy(gv->name,name,size);
59373 gv->get_attr = get_attr;
59374 gv->set_attr = set_attr;
59375 gv->next = v->vars;
59376 }
59377 }
59378 v->vars = gv;
59379 }
59380
59381 SWIGINTERN PyObject *
59382 SWIG_globals() {
59383 static PyObject *_SWIG_globals = 0;
59384 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
59385 return _SWIG_globals;
59386 }
59387
59388 /* -----------------------------------------------------------------------------
59389 * constants/methods manipulation
59390 * ----------------------------------------------------------------------------- */
59391
59392 /* Install Constants */
59393 SWIGINTERN void
59394 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
59395 PyObject *obj = 0;
59396 size_t i;
59397 for (i = 0; constants[i].type; ++i) {
59398 switch(constants[i].type) {
59399 case SWIG_PY_POINTER:
59400 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
59401 break;
59402 case SWIG_PY_BINARY:
59403 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
59404 break;
59405 default:
59406 obj = 0;
59407 break;
59408 }
59409 if (obj) {
59410 PyDict_SetItemString(d, constants[i].name, obj);
59411 Py_DECREF(obj);
59412 }
59413 }
59414 }
59415
59416 /* -----------------------------------------------------------------------------*/
59417 /* Fix SwigMethods to carry the callback ptrs when needed */
59418 /* -----------------------------------------------------------------------------*/
59419
59420 SWIGINTERN void
59421 SWIG_Python_FixMethods(PyMethodDef *methods,
59422 swig_const_info *const_table,
59423 swig_type_info **types,
59424 swig_type_info **types_initial) {
59425 size_t i;
59426 for (i = 0; methods[i].ml_name; ++i) {
59427 const char *c = methods[i].ml_doc;
59428 if (c && (c = strstr(c, "swig_ptr: "))) {
59429 int j;
59430 swig_const_info *ci = 0;
59431 const char *name = c + 10;
59432 for (j = 0; const_table[j].type; ++j) {
59433 if (strncmp(const_table[j].name, name,
59434 strlen(const_table[j].name)) == 0) {
59435 ci = &(const_table[j]);
59436 break;
59437 }
59438 }
59439 if (ci) {
59440 size_t shift = (ci->ptype) - types;
59441 swig_type_info *ty = types_initial[shift];
59442 size_t ldoc = (c - methods[i].ml_doc);
59443 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
59444 char *ndoc = (char*)malloc(ldoc + lptr + 10);
59445 if (ndoc) {
59446 char *buff = ndoc;
59447 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
59448 if (ptr) {
59449 strncpy(buff, methods[i].ml_doc, ldoc);
59450 buff += ldoc;
59451 strncpy(buff, "swig_ptr: ", 10);
59452 buff += 10;
59453 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
59454 methods[i].ml_doc = ndoc;
59455 }
59456 }
59457 }
59458 }
59459 }
59460 }
59461
59462 #ifdef __cplusplus
59463 }
59464 #endif
59465
59466 /* -----------------------------------------------------------------------------*
59467 * Partial Init method
59468 * -----------------------------------------------------------------------------*/
59469
59470 #ifdef __cplusplus
59471 extern "C"
59472 #endif
59473 SWIGEXPORT void SWIG_init(void) {
59474 PyObject *m, *d;
59475
59476 /* Fix SwigMethods to carry the callback ptrs when needed */
59477 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
59478
59479 m = Py_InitModule((char *) SWIG_name, SwigMethods);
59480 d = PyModule_GetDict(m);
59481
59482 SWIG_InitializeModule(0);
59483 SWIG_InstallConstants(d,swig_const_table);
59484
59485
59486
59487 #ifndef wxPyUSE_EXPORT
59488 // Make our API structure a CObject so other modules can import it
59489 // from this module.
59490 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
59491 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
59492 Py_XDECREF(cobj);
59493 #endif
59494
59495 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
59496 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
59497 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
59498 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
59499 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
59500 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
59501 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
59502 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
59503 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
59504 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
59505 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
59506 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
59507 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
59508 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
59509 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
59510 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
59511 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
59512 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
59513 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
59514 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
59515 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
59516 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
59517 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
59518 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
59519 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
59520 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
59521 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
59522 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
59523 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
59524 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
59525 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
59526 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
59527 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
59528 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
59529 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
59530 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
59531 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
59532 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
59533 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
59534 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
59535 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
59536 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
59537 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
59538 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
59539 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
59540 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
59541 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
59542 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
59543 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
59544 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
59545 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
59546 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
59547 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
59548 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
59549 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
59550 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
59551 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
59552 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
59553 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
59554 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
59555 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
59556 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
59557 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
59558 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
59559 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
59560 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
59561 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
59562 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
59563 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
59564 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
59565 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
59566 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
59567 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
59568 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
59569 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
59570 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
59571 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
59572 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
59573 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
59574 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
59575 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
59576 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
59577 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
59578 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
59579 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
59580 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
59581 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
59582 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
59583 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
59584 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
59585 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
59586 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
59587 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
59588 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
59589 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
59590 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
59591 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
59592 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
59593 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
59594 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
59595 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
59596 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
59597 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
59598 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
59599 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
59600 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
59601 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
59602 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
59603 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
59604 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
59605 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
59606 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
59607 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
59608 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
59609 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
59610 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
59611 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
59612 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
59613 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
59614 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
59615 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
59616 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
59617 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
59618 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
59619 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
59620 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
59621 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
59622 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
59623 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
59624 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
59625 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
59626 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
59627 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
59628 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
59629 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
59630 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
59631 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
59632 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
59633 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
59634 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
59635 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
59636 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
59637 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
59638 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
59639 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
59640 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
59641 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
59642 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
59643 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
59644 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
59645 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
59646 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
59647 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
59648 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
59649 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
59650 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
59651 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
59652 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
59653 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
59654 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
59655 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
59656 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
59657 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
59658 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
59659 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
59660 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
59661 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
59662 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
59663 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
59664 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
59665 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
59666 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
59667 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
59668 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
59669 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
59670 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
59671 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
59672 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
59673 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
59674 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
59675 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
59676 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
59677 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
59678 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
59679 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
59680 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
59681 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
59682 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
59683 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
59684 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
59685 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
59686 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
59687 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
59688 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
59689 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
59690 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
59691 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
59692 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
59693 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
59694 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
59695 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
59696 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
59697 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
59698 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
59699 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
59700 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
59701 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
59702 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
59703 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
59704 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
59705 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
59706 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
59707 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
59708 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
59709 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
59710 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
59711 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
59712 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
59713 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
59714 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
59715 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
59716 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
59717 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
59718 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
59719 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
59720 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
59721 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
59722 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
59723 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
59724 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
59725 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
59726 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
59727 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
59728 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
59729 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
59730 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
59731 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
59732 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
59733 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
59734 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
59735 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
59736 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
59737 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
59738 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
59739 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
59740 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
59741 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
59742 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
59743 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
59744 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
59745 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
59746 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
59747 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
59748 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
59749 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
59750 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
59751 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
59752 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
59753 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
59754 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
59755 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
59756 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
59757 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
59758 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
59759 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
59760 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
59761 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
59762 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
59763 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
59764 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
59765 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
59766 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
59767 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
59768 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
59769 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
59770 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
59771 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
59772 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
59773 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
59774 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
59775 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
59776 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
59777 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
59778 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
59779 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
59780 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
59781 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
59782 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
59783 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
59784 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
59785 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
59786 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
59787 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
59788 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
59789 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
59790 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
59791 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
59792 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
59793 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
59794 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
59795 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
59796 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
59797 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
59798 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
59799 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
59800 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
59801 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
59802 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
59803 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
59804 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
59805 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
59806 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
59807 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
59808 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
59809 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
59810 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
59811 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
59812 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
59813 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
59814 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
59815 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
59816 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
59817 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
59818 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
59819 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
59820 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
59821 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
59822 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
59823 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
59824 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
59825 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
59826 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
59827 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
59828 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
59829 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
59830 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
59831 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
59832 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
59833 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
59834 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
59835 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
59836 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
59837 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
59838 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
59839 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
59840 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
59841 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
59842 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
59843 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
59844 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
59845 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
59846 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
59847 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
59848 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
59849 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
59850 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
59851 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
59852 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
59853 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
59854 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
59855 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
59856 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
59857 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
59858 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
59859 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
59860 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
59861 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
59862 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
59863 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
59864 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
59865 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
59866 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
59867 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
59868 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
59869 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
59870 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
59871 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
59872 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
59873 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
59874 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
59875 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
59876 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
59877 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
59878 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
59879 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
59880 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
59881 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
59882 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
59883 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
59884 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
59885 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
59886 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
59887 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
59888 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
59889 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
59890 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
59891 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
59892 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
59893 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
59894 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
59895 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
59896 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
59897 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
59898 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
59899 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
59900 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
59901 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
59902 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
59903 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
59904 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
59905 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
59906 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
59907 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
59908 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
59909 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
59910 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
59911 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
59912 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
59913 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
59914 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
59915 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
59916 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
59917 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
59918 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
59919 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
59920 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
59921 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
59922 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
59923 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
59924 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
59925 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
59926 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
59927 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
59928 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
59929 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
59930 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
59931 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
59932 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
59933 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
59934 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
59935 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
59936 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
59937 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
59938 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
59939 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
59940 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
59941 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
59942 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
59943 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
59944 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
59945 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
59946 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
59947 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
59948 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
59949 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
59950 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
59951 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
59952 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
59953 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
59954 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
59955 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
59956 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
59957 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
59958 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
59959 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
59960 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
59961 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
59962 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
59963 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
59964 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
59965 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
59966 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
59967 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
59968 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
59969 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
59970 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
59971 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
59972 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
59973 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
59974 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
59975 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
59976 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
59977 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
59978 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
59979 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
59980 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
59981 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
59982 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
59983 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
59984 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
59985 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
59986 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
59987 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
59988 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
59989 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
59990 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
59991 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
59992 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
59993 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
59994 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
59995 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
59996 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
59997 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
59998 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
59999 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
60000 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
60001 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
60002 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
60003 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
60004 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
60005 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
60006 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
60007 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
60008 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
60009 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
60010 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
60011 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
60012 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
60013 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
60014 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
60015 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
60016 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
60017 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
60018 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
60019 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
60020 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
60021 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
60022 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
60023 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
60024 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
60025 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
60026 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
60027 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
60028 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
60029 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
60030 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
60031 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
60032 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
60033 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
60034 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
60035 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
60036 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
60037 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
60038 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
60039 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
60040 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
60041 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
60042 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
60043 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
60044 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
60045 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
60046 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
60047 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
60048 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
60049 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
60050 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
60051 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
60052 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
60053 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
60054 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
60055 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
60056 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
60057 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
60058 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
60059 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
60060 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
60061 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
60062 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
60063 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
60064 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
60065 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
60066 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
60067 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
60068 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
60069 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
60070 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
60071 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
60072 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
60073 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
60074 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
60075 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
60076 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
60077 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
60078 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
60079 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
60080 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
60081 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
60082 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
60083 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
60084 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
60085 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
60086 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
60087 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
60088 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
60089 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
60090 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
60091 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
60092 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
60093 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
60094 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
60095 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
60096 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
60097 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
60098 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
60099 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
60100 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
60101 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
60102 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
60103 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
60104 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
60105 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
60106 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
60107 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
60108 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
60109 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
60110 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
60111 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
60112 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
60113 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
60114 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
60115 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
60116 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TGA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TGA)));
60117 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
60118 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
60119 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
60120 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
60121 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
60122 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
60123 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
60124 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
60125 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
60126 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
60127 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
60128 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
60129 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
60130 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
60131 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
60132 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
60133 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
60134 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
60135 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
60136 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
60137 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
60138 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
60139 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
60140 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
60141 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
60142 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
60143 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
60144 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
60145 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
60146 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
60147 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
60148 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
60149 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
60150 SWIG_Python_SetConstant(d, "Inside",SWIG_From_int(static_cast< int >(wxInside)));
60151 SWIG_Python_SetConstant(d, "OutLeft",SWIG_From_int(static_cast< int >(wxOutLeft)));
60152 SWIG_Python_SetConstant(d, "OutRight",SWIG_From_int(static_cast< int >(wxOutRight)));
60153 SWIG_Python_SetConstant(d, "OutTop",SWIG_From_int(static_cast< int >(wxOutTop)));
60154 SWIG_Python_SetConstant(d, "OutBottom",SWIG_From_int(static_cast< int >(wxOutBottom)));
60155 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
60156 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
60157 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
60158 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
60159 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
60160
60161 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
60162
60163
60164 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
60165
60166 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
60167 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
60168 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
60169 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
60170 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
60171 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
60172 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
60173 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
60174 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
60175 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
60176 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
60177 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
60178 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
60179 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
60180 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
60181 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
60182 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
60183 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
60184 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
60185 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
60186 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
60187 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
60188 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
60189 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
60190 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
60191 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
60192 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
60193 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
60194 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
60195 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
60196 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
60197 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
60198 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
60199 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
60200 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
60201 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
60202 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
60203 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
60204 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
60205 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
60206 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
60207 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
60208 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
60209 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
60210 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
60211 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
60212 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
60213 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
60214 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
60215 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
60216 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
60217 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
60218 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
60219 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
60220 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
60221 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
60222 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
60223 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
60224 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
60225 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
60226 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
60227 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
60228 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
60229 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
60230 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
60231 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
60232 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
60233 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
60234 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
60235 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
60236 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
60237 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
60238 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
60239 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
60240 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
60241 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
60242 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
60243 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
60244 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
60245 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
60246 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
60247 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
60248 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
60249 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
60250 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
60251 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
60252 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
60253 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
60254 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
60255 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
60256 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
60257 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
60258 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
60259 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
60260 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
60261 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
60262 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
60263 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
60264 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
60265 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
60266 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
60267 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
60268 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
60269 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
60270 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
60271 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
60272 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
60273 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
60274 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
60275 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
60276 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
60277 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
60278 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
60279 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
60280 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
60281 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
60282 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
60283 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
60284 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
60285 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
60286 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
60287 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
60288 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
60289 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
60290 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
60291 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
60292 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
60293 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
60294 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
60295 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
60296 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
60297 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
60298 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
60299 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
60300 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
60301 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
60302 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
60303 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
60304 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
60305 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
60306 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
60307 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
60308 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
60309 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
60310 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
60311 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
60312 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
60313 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
60314 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
60315 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
60316 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
60317 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
60318 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
60319 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
60320 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
60321 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
60322 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
60323 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
60324 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
60325 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
60326 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
60327 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
60328 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
60329 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
60330 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
60331 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
60332 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
60333 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
60334 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
60335 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
60336 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
60337 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
60338 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
60339 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
60340 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
60341 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
60342 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
60343 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
60344 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
60345 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
60346 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
60347 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
60348 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
60349 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
60350 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
60351 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
60352 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
60353 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
60354 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
60355 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
60356 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
60357 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
60358 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
60359 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
60360 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
60361 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
60362 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
60363 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
60364 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
60365 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
60366 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
60367 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
60368 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
60369 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
60370 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
60371 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
60372 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
60373 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
60374 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
60375 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
60376 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
60377 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
60378 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
60379 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
60380
60381 // Initialize threading, some globals and such
60382 __wxPyPreStart(d);
60383
60384
60385 // Although these are defined in __version__ they need to be here too so
60386 // that an assert can be done to ensure that the wxPython and the wxWindows
60387 // versions match.
60388 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
60389 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
60390 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
60391
60392 }
60393
wxWidgets (Impactor)