]> 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
2.7 --> 2.8
[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 ;
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 *)"OOOO: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 ecode4 = SWIG_AsVal_bool(obj3, &val4);
29981 if (!SWIG_IsOK(ecode4)) {
29982 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
29983 }
29984 arg4 = static_cast< bool >(val4);
29985 {
29986 PyThreadState* __tstate = wxPyBeginAllowThreads();
29987 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
29988 wxPyEndAllowThreads(__tstate);
29989 if (PyErr_Occurred()) SWIG_fail;
29990 }
29991 resultobj = SWIG_Py_Void();
29992 return resultobj;
29993 fail:
29994 return NULL;
29995 }
29996
29997
29998 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29999 PyObject *resultobj = 0;
30000 wxPyApp *arg1 = (wxPyApp *) 0 ;
30001 wxString result;
30002 void *argp1 = 0 ;
30003 int res1 = 0 ;
30004 PyObject *swig_obj[1] ;
30005
30006 if (!args) SWIG_fail;
30007 swig_obj[0] = args;
30008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30009 if (!SWIG_IsOK(res1)) {
30010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30011 }
30012 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30013 {
30014 PyThreadState* __tstate = wxPyBeginAllowThreads();
30015 result = ((wxPyApp const *)arg1)->GetAppName();
30016 wxPyEndAllowThreads(__tstate);
30017 if (PyErr_Occurred()) SWIG_fail;
30018 }
30019 {
30020 #if wxUSE_UNICODE
30021 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30022 #else
30023 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30024 #endif
30025 }
30026 return resultobj;
30027 fail:
30028 return NULL;
30029 }
30030
30031
30032 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30033 PyObject *resultobj = 0;
30034 wxPyApp *arg1 = (wxPyApp *) 0 ;
30035 wxString *arg2 = 0 ;
30036 void *argp1 = 0 ;
30037 int res1 = 0 ;
30038 bool temp2 = false ;
30039 PyObject * obj0 = 0 ;
30040 PyObject * obj1 = 0 ;
30041 char * kwnames[] = {
30042 (char *) "self",(char *) "name", NULL
30043 };
30044
30045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
30046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30047 if (!SWIG_IsOK(res1)) {
30048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30049 }
30050 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30051 {
30052 arg2 = wxString_in_helper(obj1);
30053 if (arg2 == NULL) SWIG_fail;
30054 temp2 = true;
30055 }
30056 {
30057 PyThreadState* __tstate = wxPyBeginAllowThreads();
30058 (arg1)->SetAppName((wxString const &)*arg2);
30059 wxPyEndAllowThreads(__tstate);
30060 if (PyErr_Occurred()) SWIG_fail;
30061 }
30062 resultobj = SWIG_Py_Void();
30063 {
30064 if (temp2)
30065 delete arg2;
30066 }
30067 return resultobj;
30068 fail:
30069 {
30070 if (temp2)
30071 delete arg2;
30072 }
30073 return NULL;
30074 }
30075
30076
30077 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30078 PyObject *resultobj = 0;
30079 wxPyApp *arg1 = (wxPyApp *) 0 ;
30080 wxString result;
30081 void *argp1 = 0 ;
30082 int res1 = 0 ;
30083 PyObject *swig_obj[1] ;
30084
30085 if (!args) SWIG_fail;
30086 swig_obj[0] = args;
30087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30088 if (!SWIG_IsOK(res1)) {
30089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30090 }
30091 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30092 {
30093 PyThreadState* __tstate = wxPyBeginAllowThreads();
30094 result = ((wxPyApp const *)arg1)->GetClassName();
30095 wxPyEndAllowThreads(__tstate);
30096 if (PyErr_Occurred()) SWIG_fail;
30097 }
30098 {
30099 #if wxUSE_UNICODE
30100 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30101 #else
30102 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30103 #endif
30104 }
30105 return resultobj;
30106 fail:
30107 return NULL;
30108 }
30109
30110
30111 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30112 PyObject *resultobj = 0;
30113 wxPyApp *arg1 = (wxPyApp *) 0 ;
30114 wxString *arg2 = 0 ;
30115 void *argp1 = 0 ;
30116 int res1 = 0 ;
30117 bool temp2 = false ;
30118 PyObject * obj0 = 0 ;
30119 PyObject * obj1 = 0 ;
30120 char * kwnames[] = {
30121 (char *) "self",(char *) "name", NULL
30122 };
30123
30124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
30125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30126 if (!SWIG_IsOK(res1)) {
30127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30128 }
30129 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30130 {
30131 arg2 = wxString_in_helper(obj1);
30132 if (arg2 == NULL) SWIG_fail;
30133 temp2 = true;
30134 }
30135 {
30136 PyThreadState* __tstate = wxPyBeginAllowThreads();
30137 (arg1)->SetClassName((wxString const &)*arg2);
30138 wxPyEndAllowThreads(__tstate);
30139 if (PyErr_Occurred()) SWIG_fail;
30140 }
30141 resultobj = SWIG_Py_Void();
30142 {
30143 if (temp2)
30144 delete arg2;
30145 }
30146 return resultobj;
30147 fail:
30148 {
30149 if (temp2)
30150 delete arg2;
30151 }
30152 return NULL;
30153 }
30154
30155
30156 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30157 PyObject *resultobj = 0;
30158 wxPyApp *arg1 = (wxPyApp *) 0 ;
30159 wxString *result = 0 ;
30160 void *argp1 = 0 ;
30161 int res1 = 0 ;
30162 PyObject *swig_obj[1] ;
30163
30164 if (!args) SWIG_fail;
30165 swig_obj[0] = args;
30166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30167 if (!SWIG_IsOK(res1)) {
30168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30169 }
30170 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30171 {
30172 PyThreadState* __tstate = wxPyBeginAllowThreads();
30173 {
30174 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
30175 result = (wxString *) &_result_ref;
30176 }
30177 wxPyEndAllowThreads(__tstate);
30178 if (PyErr_Occurred()) SWIG_fail;
30179 }
30180 {
30181 #if wxUSE_UNICODE
30182 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
30183 #else
30184 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
30185 #endif
30186 }
30187 return resultobj;
30188 fail:
30189 return NULL;
30190 }
30191
30192
30193 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30194 PyObject *resultobj = 0;
30195 wxPyApp *arg1 = (wxPyApp *) 0 ;
30196 wxString *arg2 = 0 ;
30197 void *argp1 = 0 ;
30198 int res1 = 0 ;
30199 bool temp2 = false ;
30200 PyObject * obj0 = 0 ;
30201 PyObject * obj1 = 0 ;
30202 char * kwnames[] = {
30203 (char *) "self",(char *) "name", NULL
30204 };
30205
30206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
30207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30208 if (!SWIG_IsOK(res1)) {
30209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30210 }
30211 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30212 {
30213 arg2 = wxString_in_helper(obj1);
30214 if (arg2 == NULL) SWIG_fail;
30215 temp2 = true;
30216 }
30217 {
30218 PyThreadState* __tstate = wxPyBeginAllowThreads();
30219 (arg1)->SetVendorName((wxString const &)*arg2);
30220 wxPyEndAllowThreads(__tstate);
30221 if (PyErr_Occurred()) SWIG_fail;
30222 }
30223 resultobj = SWIG_Py_Void();
30224 {
30225 if (temp2)
30226 delete arg2;
30227 }
30228 return resultobj;
30229 fail:
30230 {
30231 if (temp2)
30232 delete arg2;
30233 }
30234 return NULL;
30235 }
30236
30237
30238 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30239 PyObject *resultobj = 0;
30240 wxPyApp *arg1 = (wxPyApp *) 0 ;
30241 wxAppTraits *result = 0 ;
30242 void *argp1 = 0 ;
30243 int res1 = 0 ;
30244 PyObject *swig_obj[1] ;
30245
30246 if (!args) SWIG_fail;
30247 swig_obj[0] = args;
30248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30249 if (!SWIG_IsOK(res1)) {
30250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
30251 }
30252 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30253 {
30254 PyThreadState* __tstate = wxPyBeginAllowThreads();
30255 result = (wxAppTraits *)(arg1)->GetTraits();
30256 wxPyEndAllowThreads(__tstate);
30257 if (PyErr_Occurred()) SWIG_fail;
30258 }
30259 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
30260 return resultobj;
30261 fail:
30262 return NULL;
30263 }
30264
30265
30266 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30267 PyObject *resultobj = 0;
30268 wxPyApp *arg1 = (wxPyApp *) 0 ;
30269 void *argp1 = 0 ;
30270 int res1 = 0 ;
30271 PyObject *swig_obj[1] ;
30272
30273 if (!args) SWIG_fail;
30274 swig_obj[0] = args;
30275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30276 if (!SWIG_IsOK(res1)) {
30277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30278 }
30279 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30280 {
30281 PyThreadState* __tstate = wxPyBeginAllowThreads();
30282 (arg1)->ProcessPendingEvents();
30283 wxPyEndAllowThreads(__tstate);
30284 if (PyErr_Occurred()) SWIG_fail;
30285 }
30286 resultobj = SWIG_Py_Void();
30287 return resultobj;
30288 fail:
30289 return NULL;
30290 }
30291
30292
30293 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30294 PyObject *resultobj = 0;
30295 wxPyApp *arg1 = (wxPyApp *) 0 ;
30296 bool arg2 = (bool) false ;
30297 bool result;
30298 void *argp1 = 0 ;
30299 int res1 = 0 ;
30300 bool val2 ;
30301 int ecode2 = 0 ;
30302 PyObject * obj0 = 0 ;
30303 PyObject * obj1 = 0 ;
30304 char * kwnames[] = {
30305 (char *) "self",(char *) "onlyIfNeeded", NULL
30306 };
30307
30308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
30309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30310 if (!SWIG_IsOK(res1)) {
30311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
30312 }
30313 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30314 if (obj1) {
30315 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30316 if (!SWIG_IsOK(ecode2)) {
30317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
30318 }
30319 arg2 = static_cast< bool >(val2);
30320 }
30321 {
30322 PyThreadState* __tstate = wxPyBeginAllowThreads();
30323 result = (bool)(arg1)->Yield(arg2);
30324 wxPyEndAllowThreads(__tstate);
30325 if (PyErr_Occurred()) SWIG_fail;
30326 }
30327 {
30328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30329 }
30330 return resultobj;
30331 fail:
30332 return NULL;
30333 }
30334
30335
30336 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30337 PyObject *resultobj = 0;
30338 wxPyApp *arg1 = (wxPyApp *) 0 ;
30339 void *argp1 = 0 ;
30340 int res1 = 0 ;
30341 PyObject *swig_obj[1] ;
30342
30343 if (!args) SWIG_fail;
30344 swig_obj[0] = args;
30345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30346 if (!SWIG_IsOK(res1)) {
30347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30348 }
30349 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30350 {
30351 PyThreadState* __tstate = wxPyBeginAllowThreads();
30352 (arg1)->WakeUpIdle();
30353 wxPyEndAllowThreads(__tstate);
30354 if (PyErr_Occurred()) SWIG_fail;
30355 }
30356 resultobj = SWIG_Py_Void();
30357 return resultobj;
30358 fail:
30359 return NULL;
30360 }
30361
30362
30363 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30364 PyObject *resultobj = 0;
30365 bool result;
30366
30367 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
30368 {
30369 PyThreadState* __tstate = wxPyBeginAllowThreads();
30370 result = (bool)wxPyApp::IsMainLoopRunning();
30371 wxPyEndAllowThreads(__tstate);
30372 if (PyErr_Occurred()) SWIG_fail;
30373 }
30374 {
30375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30376 }
30377 return resultobj;
30378 fail:
30379 return NULL;
30380 }
30381
30382
30383 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30384 PyObject *resultobj = 0;
30385 wxPyApp *arg1 = (wxPyApp *) 0 ;
30386 int result;
30387 void *argp1 = 0 ;
30388 int res1 = 0 ;
30389 PyObject *swig_obj[1] ;
30390
30391 if (!args) SWIG_fail;
30392 swig_obj[0] = args;
30393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30394 if (!SWIG_IsOK(res1)) {
30395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30396 }
30397 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30398 {
30399 PyThreadState* __tstate = wxPyBeginAllowThreads();
30400 result = (int)(arg1)->MainLoop();
30401 wxPyEndAllowThreads(__tstate);
30402 if (PyErr_Occurred()) SWIG_fail;
30403 }
30404 resultobj = SWIG_From_int(static_cast< int >(result));
30405 return resultobj;
30406 fail:
30407 return NULL;
30408 }
30409
30410
30411 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30412 PyObject *resultobj = 0;
30413 wxPyApp *arg1 = (wxPyApp *) 0 ;
30414 void *argp1 = 0 ;
30415 int res1 = 0 ;
30416 PyObject *swig_obj[1] ;
30417
30418 if (!args) SWIG_fail;
30419 swig_obj[0] = args;
30420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30421 if (!SWIG_IsOK(res1)) {
30422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
30423 }
30424 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30425 {
30426 PyThreadState* __tstate = wxPyBeginAllowThreads();
30427 (arg1)->Exit();
30428 wxPyEndAllowThreads(__tstate);
30429 if (PyErr_Occurred()) SWIG_fail;
30430 }
30431 resultobj = SWIG_Py_Void();
30432 return resultobj;
30433 fail:
30434 return NULL;
30435 }
30436
30437
30438 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30439 PyObject *resultobj = 0;
30440 wxPyApp *arg1 = (wxPyApp *) 0 ;
30441 wxLayoutDirection result;
30442 void *argp1 = 0 ;
30443 int res1 = 0 ;
30444 PyObject *swig_obj[1] ;
30445
30446 if (!args) SWIG_fail;
30447 swig_obj[0] = args;
30448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30449 if (!SWIG_IsOK(res1)) {
30450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30451 }
30452 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30453 {
30454 PyThreadState* __tstate = wxPyBeginAllowThreads();
30455 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
30456 wxPyEndAllowThreads(__tstate);
30457 if (PyErr_Occurred()) SWIG_fail;
30458 }
30459 resultobj = SWIG_From_int(static_cast< int >(result));
30460 return resultobj;
30461 fail:
30462 return NULL;
30463 }
30464
30465
30466 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30467 PyObject *resultobj = 0;
30468 wxPyApp *arg1 = (wxPyApp *) 0 ;
30469 void *argp1 = 0 ;
30470 int res1 = 0 ;
30471 PyObject *swig_obj[1] ;
30472
30473 if (!args) SWIG_fail;
30474 swig_obj[0] = args;
30475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30476 if (!SWIG_IsOK(res1)) {
30477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30478 }
30479 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30480 {
30481 PyThreadState* __tstate = wxPyBeginAllowThreads();
30482 (arg1)->ExitMainLoop();
30483 wxPyEndAllowThreads(__tstate);
30484 if (PyErr_Occurred()) SWIG_fail;
30485 }
30486 resultobj = SWIG_Py_Void();
30487 return resultobj;
30488 fail:
30489 return NULL;
30490 }
30491
30492
30493 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30494 PyObject *resultobj = 0;
30495 wxPyApp *arg1 = (wxPyApp *) 0 ;
30496 bool result;
30497 void *argp1 = 0 ;
30498 int res1 = 0 ;
30499 PyObject *swig_obj[1] ;
30500
30501 if (!args) SWIG_fail;
30502 swig_obj[0] = args;
30503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30504 if (!SWIG_IsOK(res1)) {
30505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
30506 }
30507 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30508 {
30509 PyThreadState* __tstate = wxPyBeginAllowThreads();
30510 result = (bool)(arg1)->Pending();
30511 wxPyEndAllowThreads(__tstate);
30512 if (PyErr_Occurred()) SWIG_fail;
30513 }
30514 {
30515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30516 }
30517 return resultobj;
30518 fail:
30519 return NULL;
30520 }
30521
30522
30523 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30524 PyObject *resultobj = 0;
30525 wxPyApp *arg1 = (wxPyApp *) 0 ;
30526 bool result;
30527 void *argp1 = 0 ;
30528 int res1 = 0 ;
30529 PyObject *swig_obj[1] ;
30530
30531 if (!args) SWIG_fail;
30532 swig_obj[0] = args;
30533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30534 if (!SWIG_IsOK(res1)) {
30535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
30536 }
30537 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30538 {
30539 PyThreadState* __tstate = wxPyBeginAllowThreads();
30540 result = (bool)(arg1)->Dispatch();
30541 wxPyEndAllowThreads(__tstate);
30542 if (PyErr_Occurred()) SWIG_fail;
30543 }
30544 {
30545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30546 }
30547 return resultobj;
30548 fail:
30549 return NULL;
30550 }
30551
30552
30553 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30554 PyObject *resultobj = 0;
30555 wxPyApp *arg1 = (wxPyApp *) 0 ;
30556 bool result;
30557 void *argp1 = 0 ;
30558 int res1 = 0 ;
30559 PyObject *swig_obj[1] ;
30560
30561 if (!args) SWIG_fail;
30562 swig_obj[0] = args;
30563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30564 if (!SWIG_IsOK(res1)) {
30565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30566 }
30567 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30568 {
30569 PyThreadState* __tstate = wxPyBeginAllowThreads();
30570 result = (bool)(arg1)->ProcessIdle();
30571 wxPyEndAllowThreads(__tstate);
30572 if (PyErr_Occurred()) SWIG_fail;
30573 }
30574 {
30575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30576 }
30577 return resultobj;
30578 fail:
30579 return NULL;
30580 }
30581
30582
30583 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30584 PyObject *resultobj = 0;
30585 wxPyApp *arg1 = (wxPyApp *) 0 ;
30586 wxWindow *arg2 = (wxWindow *) 0 ;
30587 wxIdleEvent *arg3 = 0 ;
30588 bool result;
30589 void *argp1 = 0 ;
30590 int res1 = 0 ;
30591 void *argp2 = 0 ;
30592 int res2 = 0 ;
30593 void *argp3 = 0 ;
30594 int res3 = 0 ;
30595 PyObject * obj0 = 0 ;
30596 PyObject * obj1 = 0 ;
30597 PyObject * obj2 = 0 ;
30598 char * kwnames[] = {
30599 (char *) "self",(char *) "win",(char *) "event", NULL
30600 };
30601
30602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30604 if (!SWIG_IsOK(res1)) {
30605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30606 }
30607 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30608 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30609 if (!SWIG_IsOK(res2)) {
30610 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
30611 }
30612 arg2 = reinterpret_cast< wxWindow * >(argp2);
30613 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
30614 if (!SWIG_IsOK(res3)) {
30615 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30616 }
30617 if (!argp3) {
30618 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30619 }
30620 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
30621 {
30622 PyThreadState* __tstate = wxPyBeginAllowThreads();
30623 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
30624 wxPyEndAllowThreads(__tstate);
30625 if (PyErr_Occurred()) SWIG_fail;
30626 }
30627 {
30628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30629 }
30630 return resultobj;
30631 fail:
30632 return NULL;
30633 }
30634
30635
30636 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30637 PyObject *resultobj = 0;
30638 wxPyApp *arg1 = (wxPyApp *) 0 ;
30639 bool result;
30640 void *argp1 = 0 ;
30641 int res1 = 0 ;
30642 PyObject *swig_obj[1] ;
30643
30644 if (!args) SWIG_fail;
30645 swig_obj[0] = args;
30646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30647 if (!SWIG_IsOK(res1)) {
30648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30649 }
30650 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30651 {
30652 PyThreadState* __tstate = wxPyBeginAllowThreads();
30653 result = (bool)((wxPyApp const *)arg1)->IsActive();
30654 wxPyEndAllowThreads(__tstate);
30655 if (PyErr_Occurred()) SWIG_fail;
30656 }
30657 {
30658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30659 }
30660 return resultobj;
30661 fail:
30662 return NULL;
30663 }
30664
30665
30666 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30667 PyObject *resultobj = 0;
30668 wxPyApp *arg1 = (wxPyApp *) 0 ;
30669 wxWindow *arg2 = (wxWindow *) 0 ;
30670 void *argp1 = 0 ;
30671 int res1 = 0 ;
30672 void *argp2 = 0 ;
30673 int res2 = 0 ;
30674 PyObject * obj0 = 0 ;
30675 PyObject * obj1 = 0 ;
30676 char * kwnames[] = {
30677 (char *) "self",(char *) "win", NULL
30678 };
30679
30680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
30681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30682 if (!SWIG_IsOK(res1)) {
30683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
30684 }
30685 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30686 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30687 if (!SWIG_IsOK(res2)) {
30688 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
30689 }
30690 arg2 = reinterpret_cast< wxWindow * >(argp2);
30691 {
30692 PyThreadState* __tstate = wxPyBeginAllowThreads();
30693 (arg1)->SetTopWindow(arg2);
30694 wxPyEndAllowThreads(__tstate);
30695 if (PyErr_Occurred()) SWIG_fail;
30696 }
30697 resultobj = SWIG_Py_Void();
30698 return resultobj;
30699 fail:
30700 return NULL;
30701 }
30702
30703
30704 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30705 PyObject *resultobj = 0;
30706 wxPyApp *arg1 = (wxPyApp *) 0 ;
30707 wxWindow *result = 0 ;
30708 void *argp1 = 0 ;
30709 int res1 = 0 ;
30710 PyObject *swig_obj[1] ;
30711
30712 if (!args) SWIG_fail;
30713 swig_obj[0] = args;
30714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30715 if (!SWIG_IsOK(res1)) {
30716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30717 }
30718 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30719 {
30720 PyThreadState* __tstate = wxPyBeginAllowThreads();
30721 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
30722 wxPyEndAllowThreads(__tstate);
30723 if (PyErr_Occurred()) SWIG_fail;
30724 }
30725 {
30726 resultobj = wxPyMake_wxObject(result, (bool)0);
30727 }
30728 return resultobj;
30729 fail:
30730 return NULL;
30731 }
30732
30733
30734 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30735 PyObject *resultobj = 0;
30736 wxPyApp *arg1 = (wxPyApp *) 0 ;
30737 bool arg2 ;
30738 void *argp1 = 0 ;
30739 int res1 = 0 ;
30740 bool val2 ;
30741 int ecode2 = 0 ;
30742 PyObject * obj0 = 0 ;
30743 PyObject * obj1 = 0 ;
30744 char * kwnames[] = {
30745 (char *) "self",(char *) "flag", NULL
30746 };
30747
30748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
30749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30750 if (!SWIG_IsOK(res1)) {
30751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
30752 }
30753 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30754 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30755 if (!SWIG_IsOK(ecode2)) {
30756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
30757 }
30758 arg2 = static_cast< bool >(val2);
30759 {
30760 PyThreadState* __tstate = wxPyBeginAllowThreads();
30761 (arg1)->SetExitOnFrameDelete(arg2);
30762 wxPyEndAllowThreads(__tstate);
30763 if (PyErr_Occurred()) SWIG_fail;
30764 }
30765 resultobj = SWIG_Py_Void();
30766 return resultobj;
30767 fail:
30768 return NULL;
30769 }
30770
30771
30772 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30773 PyObject *resultobj = 0;
30774 wxPyApp *arg1 = (wxPyApp *) 0 ;
30775 bool result;
30776 void *argp1 = 0 ;
30777 int res1 = 0 ;
30778 PyObject *swig_obj[1] ;
30779
30780 if (!args) SWIG_fail;
30781 swig_obj[0] = args;
30782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30783 if (!SWIG_IsOK(res1)) {
30784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30785 }
30786 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30787 {
30788 PyThreadState* __tstate = wxPyBeginAllowThreads();
30789 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
30790 wxPyEndAllowThreads(__tstate);
30791 if (PyErr_Occurred()) SWIG_fail;
30792 }
30793 {
30794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30795 }
30796 return resultobj;
30797 fail:
30798 return NULL;
30799 }
30800
30801
30802 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30803 PyObject *resultobj = 0;
30804 wxPyApp *arg1 = (wxPyApp *) 0 ;
30805 bool arg2 ;
30806 void *argp1 = 0 ;
30807 int res1 = 0 ;
30808 bool val2 ;
30809 int ecode2 = 0 ;
30810 PyObject * obj0 = 0 ;
30811 PyObject * obj1 = 0 ;
30812 char * kwnames[] = {
30813 (char *) "self",(char *) "flag", NULL
30814 };
30815
30816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
30817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30818 if (!SWIG_IsOK(res1)) {
30819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
30820 }
30821 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30822 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30823 if (!SWIG_IsOK(ecode2)) {
30824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
30825 }
30826 arg2 = static_cast< bool >(val2);
30827 {
30828 PyThreadState* __tstate = wxPyBeginAllowThreads();
30829 (arg1)->SetUseBestVisual(arg2);
30830 wxPyEndAllowThreads(__tstate);
30831 if (PyErr_Occurred()) SWIG_fail;
30832 }
30833 resultobj = SWIG_Py_Void();
30834 return resultobj;
30835 fail:
30836 return NULL;
30837 }
30838
30839
30840 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30841 PyObject *resultobj = 0;
30842 wxPyApp *arg1 = (wxPyApp *) 0 ;
30843 bool result;
30844 void *argp1 = 0 ;
30845 int res1 = 0 ;
30846 PyObject *swig_obj[1] ;
30847
30848 if (!args) SWIG_fail;
30849 swig_obj[0] = args;
30850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30851 if (!SWIG_IsOK(res1)) {
30852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30853 }
30854 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30855 {
30856 PyThreadState* __tstate = wxPyBeginAllowThreads();
30857 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
30858 wxPyEndAllowThreads(__tstate);
30859 if (PyErr_Occurred()) SWIG_fail;
30860 }
30861 {
30862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30863 }
30864 return resultobj;
30865 fail:
30866 return NULL;
30867 }
30868
30869
30870 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30871 PyObject *resultobj = 0;
30872 wxPyApp *arg1 = (wxPyApp *) 0 ;
30873 int arg2 ;
30874 void *argp1 = 0 ;
30875 int res1 = 0 ;
30876 int val2 ;
30877 int ecode2 = 0 ;
30878 PyObject * obj0 = 0 ;
30879 PyObject * obj1 = 0 ;
30880 char * kwnames[] = {
30881 (char *) "self",(char *) "mode", NULL
30882 };
30883
30884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
30885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30886 if (!SWIG_IsOK(res1)) {
30887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30888 }
30889 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30890 ecode2 = SWIG_AsVal_int(obj1, &val2);
30891 if (!SWIG_IsOK(ecode2)) {
30892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
30893 }
30894 arg2 = static_cast< int >(val2);
30895 {
30896 PyThreadState* __tstate = wxPyBeginAllowThreads();
30897 (arg1)->SetPrintMode(arg2);
30898 wxPyEndAllowThreads(__tstate);
30899 if (PyErr_Occurred()) SWIG_fail;
30900 }
30901 resultobj = SWIG_Py_Void();
30902 return resultobj;
30903 fail:
30904 return NULL;
30905 }
30906
30907
30908 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30909 PyObject *resultobj = 0;
30910 wxPyApp *arg1 = (wxPyApp *) 0 ;
30911 int result;
30912 void *argp1 = 0 ;
30913 int res1 = 0 ;
30914 PyObject *swig_obj[1] ;
30915
30916 if (!args) SWIG_fail;
30917 swig_obj[0] = args;
30918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30919 if (!SWIG_IsOK(res1)) {
30920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30921 }
30922 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30923 {
30924 PyThreadState* __tstate = wxPyBeginAllowThreads();
30925 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
30926 wxPyEndAllowThreads(__tstate);
30927 if (PyErr_Occurred()) SWIG_fail;
30928 }
30929 resultobj = SWIG_From_int(static_cast< int >(result));
30930 return resultobj;
30931 fail:
30932 return NULL;
30933 }
30934
30935
30936 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30937 PyObject *resultobj = 0;
30938 wxPyApp *arg1 = (wxPyApp *) 0 ;
30939 int arg2 ;
30940 void *argp1 = 0 ;
30941 int res1 = 0 ;
30942 int val2 ;
30943 int ecode2 = 0 ;
30944 PyObject * obj0 = 0 ;
30945 PyObject * obj1 = 0 ;
30946 char * kwnames[] = {
30947 (char *) "self",(char *) "mode", NULL
30948 };
30949
30950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
30951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30952 if (!SWIG_IsOK(res1)) {
30953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30954 }
30955 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30956 ecode2 = SWIG_AsVal_int(obj1, &val2);
30957 if (!SWIG_IsOK(ecode2)) {
30958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
30959 }
30960 arg2 = static_cast< int >(val2);
30961 {
30962 PyThreadState* __tstate = wxPyBeginAllowThreads();
30963 (arg1)->SetAssertMode(arg2);
30964 wxPyEndAllowThreads(__tstate);
30965 if (PyErr_Occurred()) SWIG_fail;
30966 }
30967 resultobj = SWIG_Py_Void();
30968 return resultobj;
30969 fail:
30970 return NULL;
30971 }
30972
30973
30974 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30975 PyObject *resultobj = 0;
30976 wxPyApp *arg1 = (wxPyApp *) 0 ;
30977 int result;
30978 void *argp1 = 0 ;
30979 int res1 = 0 ;
30980 PyObject *swig_obj[1] ;
30981
30982 if (!args) SWIG_fail;
30983 swig_obj[0] = args;
30984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30985 if (!SWIG_IsOK(res1)) {
30986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30987 }
30988 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30989 {
30990 PyThreadState* __tstate = wxPyBeginAllowThreads();
30991 result = (int)(arg1)->GetAssertMode();
30992 wxPyEndAllowThreads(__tstate);
30993 if (PyErr_Occurred()) SWIG_fail;
30994 }
30995 resultobj = SWIG_From_int(static_cast< int >(result));
30996 return resultobj;
30997 fail:
30998 return NULL;
30999 }
31000
31001
31002 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31003 PyObject *resultobj = 0;
31004 bool result;
31005
31006 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
31007 {
31008 PyThreadState* __tstate = wxPyBeginAllowThreads();
31009 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
31010 wxPyEndAllowThreads(__tstate);
31011 if (PyErr_Occurred()) SWIG_fail;
31012 }
31013 {
31014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31015 }
31016 return resultobj;
31017 fail:
31018 return NULL;
31019 }
31020
31021
31022 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31023 PyObject *resultobj = 0;
31024 long result;
31025
31026 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
31027 {
31028 PyThreadState* __tstate = wxPyBeginAllowThreads();
31029 result = (long)wxPyApp::GetMacAboutMenuItemId();
31030 wxPyEndAllowThreads(__tstate);
31031 if (PyErr_Occurred()) SWIG_fail;
31032 }
31033 resultobj = SWIG_From_long(static_cast< long >(result));
31034 return resultobj;
31035 fail:
31036 return NULL;
31037 }
31038
31039
31040 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31041 PyObject *resultobj = 0;
31042 long result;
31043
31044 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
31045 {
31046 PyThreadState* __tstate = wxPyBeginAllowThreads();
31047 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
31048 wxPyEndAllowThreads(__tstate);
31049 if (PyErr_Occurred()) SWIG_fail;
31050 }
31051 resultobj = SWIG_From_long(static_cast< long >(result));
31052 return resultobj;
31053 fail:
31054 return NULL;
31055 }
31056
31057
31058 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31059 PyObject *resultobj = 0;
31060 long result;
31061
31062 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
31063 {
31064 PyThreadState* __tstate = wxPyBeginAllowThreads();
31065 result = (long)wxPyApp::GetMacExitMenuItemId();
31066 wxPyEndAllowThreads(__tstate);
31067 if (PyErr_Occurred()) SWIG_fail;
31068 }
31069 resultobj = SWIG_From_long(static_cast< long >(result));
31070 return resultobj;
31071 fail:
31072 return NULL;
31073 }
31074
31075
31076 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31077 PyObject *resultobj = 0;
31078 wxString result;
31079
31080 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
31081 {
31082 PyThreadState* __tstate = wxPyBeginAllowThreads();
31083 result = wxPyApp::GetMacHelpMenuTitleName();
31084 wxPyEndAllowThreads(__tstate);
31085 if (PyErr_Occurred()) SWIG_fail;
31086 }
31087 {
31088 #if wxUSE_UNICODE
31089 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31090 #else
31091 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31092 #endif
31093 }
31094 return resultobj;
31095 fail:
31096 return NULL;
31097 }
31098
31099
31100 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31101 PyObject *resultobj = 0;
31102 bool arg1 ;
31103 bool val1 ;
31104 int ecode1 = 0 ;
31105 PyObject * obj0 = 0 ;
31106 char * kwnames[] = {
31107 (char *) "val", NULL
31108 };
31109
31110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
31111 ecode1 = SWIG_AsVal_bool(obj0, &val1);
31112 if (!SWIG_IsOK(ecode1)) {
31113 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
31114 }
31115 arg1 = static_cast< bool >(val1);
31116 {
31117 PyThreadState* __tstate = wxPyBeginAllowThreads();
31118 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
31119 wxPyEndAllowThreads(__tstate);
31120 if (PyErr_Occurred()) SWIG_fail;
31121 }
31122 resultobj = SWIG_Py_Void();
31123 return resultobj;
31124 fail:
31125 return NULL;
31126 }
31127
31128
31129 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31130 PyObject *resultobj = 0;
31131 long arg1 ;
31132 long val1 ;
31133 int ecode1 = 0 ;
31134 PyObject * obj0 = 0 ;
31135 char * kwnames[] = {
31136 (char *) "val", NULL
31137 };
31138
31139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
31140 ecode1 = SWIG_AsVal_long(obj0, &val1);
31141 if (!SWIG_IsOK(ecode1)) {
31142 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
31143 }
31144 arg1 = static_cast< long >(val1);
31145 {
31146 PyThreadState* __tstate = wxPyBeginAllowThreads();
31147 wxPyApp::SetMacAboutMenuItemId(arg1);
31148 wxPyEndAllowThreads(__tstate);
31149 if (PyErr_Occurred()) SWIG_fail;
31150 }
31151 resultobj = SWIG_Py_Void();
31152 return resultobj;
31153 fail:
31154 return NULL;
31155 }
31156
31157
31158 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31159 PyObject *resultobj = 0;
31160 long arg1 ;
31161 long val1 ;
31162 int ecode1 = 0 ;
31163 PyObject * obj0 = 0 ;
31164 char * kwnames[] = {
31165 (char *) "val", NULL
31166 };
31167
31168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
31169 ecode1 = SWIG_AsVal_long(obj0, &val1);
31170 if (!SWIG_IsOK(ecode1)) {
31171 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
31172 }
31173 arg1 = static_cast< long >(val1);
31174 {
31175 PyThreadState* __tstate = wxPyBeginAllowThreads();
31176 wxPyApp::SetMacPreferencesMenuItemId(arg1);
31177 wxPyEndAllowThreads(__tstate);
31178 if (PyErr_Occurred()) SWIG_fail;
31179 }
31180 resultobj = SWIG_Py_Void();
31181 return resultobj;
31182 fail:
31183 return NULL;
31184 }
31185
31186
31187 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31188 PyObject *resultobj = 0;
31189 long arg1 ;
31190 long val1 ;
31191 int ecode1 = 0 ;
31192 PyObject * obj0 = 0 ;
31193 char * kwnames[] = {
31194 (char *) "val", NULL
31195 };
31196
31197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
31198 ecode1 = SWIG_AsVal_long(obj0, &val1);
31199 if (!SWIG_IsOK(ecode1)) {
31200 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
31201 }
31202 arg1 = static_cast< long >(val1);
31203 {
31204 PyThreadState* __tstate = wxPyBeginAllowThreads();
31205 wxPyApp::SetMacExitMenuItemId(arg1);
31206 wxPyEndAllowThreads(__tstate);
31207 if (PyErr_Occurred()) SWIG_fail;
31208 }
31209 resultobj = SWIG_Py_Void();
31210 return resultobj;
31211 fail:
31212 return NULL;
31213 }
31214
31215
31216 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31217 PyObject *resultobj = 0;
31218 wxString *arg1 = 0 ;
31219 bool temp1 = false ;
31220 PyObject * obj0 = 0 ;
31221 char * kwnames[] = {
31222 (char *) "val", NULL
31223 };
31224
31225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
31226 {
31227 arg1 = wxString_in_helper(obj0);
31228 if (arg1 == NULL) SWIG_fail;
31229 temp1 = true;
31230 }
31231 {
31232 PyThreadState* __tstate = wxPyBeginAllowThreads();
31233 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
31234 wxPyEndAllowThreads(__tstate);
31235 if (PyErr_Occurred()) SWIG_fail;
31236 }
31237 resultobj = SWIG_Py_Void();
31238 {
31239 if (temp1)
31240 delete arg1;
31241 }
31242 return resultobj;
31243 fail:
31244 {
31245 if (temp1)
31246 delete arg1;
31247 }
31248 return NULL;
31249 }
31250
31251
31252 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31253 PyObject *resultobj = 0;
31254 wxPyApp *arg1 = (wxPyApp *) 0 ;
31255 void *argp1 = 0 ;
31256 int res1 = 0 ;
31257 PyObject *swig_obj[1] ;
31258
31259 if (!args) SWIG_fail;
31260 swig_obj[0] = args;
31261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31262 if (!SWIG_IsOK(res1)) {
31263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
31264 }
31265 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31266 {
31267 PyThreadState* __tstate = wxPyBeginAllowThreads();
31268 (arg1)->_BootstrapApp();
31269 wxPyEndAllowThreads(__tstate);
31270 if (PyErr_Occurred()) SWIG_fail;
31271 }
31272 resultobj = SWIG_Py_Void();
31273 return resultobj;
31274 fail:
31275 return NULL;
31276 }
31277
31278
31279 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31280 PyObject *resultobj = 0;
31281 int result;
31282
31283 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
31284 {
31285 PyThreadState* __tstate = wxPyBeginAllowThreads();
31286 result = (int)wxPyApp_GetComCtl32Version();
31287 wxPyEndAllowThreads(__tstate);
31288 if (PyErr_Occurred()) SWIG_fail;
31289 }
31290 resultobj = SWIG_From_int(static_cast< int >(result));
31291 return resultobj;
31292 fail:
31293 return NULL;
31294 }
31295
31296
31297 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31298 PyObject *resultobj = 0;
31299 bool result;
31300
31301 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
31302 {
31303 PyThreadState* __tstate = wxPyBeginAllowThreads();
31304 result = (bool)wxPyApp_IsDisplayAvailable();
31305 wxPyEndAllowThreads(__tstate);
31306 if (PyErr_Occurred()) SWIG_fail;
31307 }
31308 {
31309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31310 }
31311 return resultobj;
31312 fail:
31313 return NULL;
31314 }
31315
31316
31317 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31318 PyObject *obj;
31319 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31320 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
31321 return SWIG_Py_Void();
31322 }
31323
31324 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31325 return SWIG_Python_InitShadowInstance(args);
31326 }
31327
31328 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31329 PyObject *resultobj = 0;
31330
31331 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
31332 {
31333 PyThreadState* __tstate = wxPyBeginAllowThreads();
31334 wxExit();
31335 wxPyEndAllowThreads(__tstate);
31336 if (PyErr_Occurred()) SWIG_fail;
31337 }
31338 resultobj = SWIG_Py_Void();
31339 return resultobj;
31340 fail:
31341 return NULL;
31342 }
31343
31344
31345 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31346 PyObject *resultobj = 0;
31347 bool result;
31348
31349 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
31350 {
31351 PyThreadState* __tstate = wxPyBeginAllowThreads();
31352 result = (bool)wxYield();
31353 wxPyEndAllowThreads(__tstate);
31354 if (PyErr_Occurred()) SWIG_fail;
31355 }
31356 {
31357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31358 }
31359 return resultobj;
31360 fail:
31361 return NULL;
31362 }
31363
31364
31365 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31366 PyObject *resultobj = 0;
31367 bool result;
31368
31369 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
31370 {
31371 PyThreadState* __tstate = wxPyBeginAllowThreads();
31372 result = (bool)wxYieldIfNeeded();
31373 wxPyEndAllowThreads(__tstate);
31374 if (PyErr_Occurred()) SWIG_fail;
31375 }
31376 {
31377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31378 }
31379 return resultobj;
31380 fail:
31381 return NULL;
31382 }
31383
31384
31385 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31386 PyObject *resultobj = 0;
31387 wxWindow *arg1 = (wxWindow *) NULL ;
31388 bool arg2 = (bool) false ;
31389 bool result;
31390 void *argp1 = 0 ;
31391 int res1 = 0 ;
31392 bool val2 ;
31393 int ecode2 = 0 ;
31394 PyObject * obj0 = 0 ;
31395 PyObject * obj1 = 0 ;
31396 char * kwnames[] = {
31397 (char *) "win",(char *) "onlyIfNeeded", NULL
31398 };
31399
31400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
31401 if (obj0) {
31402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31403 if (!SWIG_IsOK(res1)) {
31404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
31405 }
31406 arg1 = reinterpret_cast< wxWindow * >(argp1);
31407 }
31408 if (obj1) {
31409 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31410 if (!SWIG_IsOK(ecode2)) {
31411 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
31412 }
31413 arg2 = static_cast< bool >(val2);
31414 }
31415 {
31416 PyThreadState* __tstate = wxPyBeginAllowThreads();
31417 result = (bool)wxSafeYield(arg1,arg2);
31418 wxPyEndAllowThreads(__tstate);
31419 if (PyErr_Occurred()) SWIG_fail;
31420 }
31421 {
31422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31423 }
31424 return resultobj;
31425 fail:
31426 return NULL;
31427 }
31428
31429
31430 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31431 PyObject *resultobj = 0;
31432
31433 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
31434 {
31435 PyThreadState* __tstate = wxPyBeginAllowThreads();
31436 wxWakeUpIdle();
31437 wxPyEndAllowThreads(__tstate);
31438 if (PyErr_Occurred()) SWIG_fail;
31439 }
31440 resultobj = SWIG_Py_Void();
31441 return resultobj;
31442 fail:
31443 return NULL;
31444 }
31445
31446
31447 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31448 PyObject *resultobj = 0;
31449 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
31450 wxEvent *arg2 = 0 ;
31451 void *argp1 = 0 ;
31452 int res1 = 0 ;
31453 void *argp2 = 0 ;
31454 int res2 = 0 ;
31455 PyObject * obj0 = 0 ;
31456 PyObject * obj1 = 0 ;
31457 char * kwnames[] = {
31458 (char *) "dest",(char *) "event", NULL
31459 };
31460
31461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
31462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
31463 if (!SWIG_IsOK(res1)) {
31464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
31465 }
31466 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
31467 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
31468 if (!SWIG_IsOK(res2)) {
31469 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31470 }
31471 if (!argp2) {
31472 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31473 }
31474 arg2 = reinterpret_cast< wxEvent * >(argp2);
31475 {
31476 PyThreadState* __tstate = wxPyBeginAllowThreads();
31477 wxPostEvent(arg1,*arg2);
31478 wxPyEndAllowThreads(__tstate);
31479 if (PyErr_Occurred()) SWIG_fail;
31480 }
31481 resultobj = SWIG_Py_Void();
31482 return resultobj;
31483 fail:
31484 return NULL;
31485 }
31486
31487
31488 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31489 PyObject *resultobj = 0;
31490
31491 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
31492 {
31493 PyThreadState* __tstate = wxPyBeginAllowThreads();
31494 wxApp_CleanUp();
31495 wxPyEndAllowThreads(__tstate);
31496 if (PyErr_Occurred()) SWIG_fail;
31497 }
31498 resultobj = SWIG_Py_Void();
31499 return resultobj;
31500 fail:
31501 return NULL;
31502 }
31503
31504
31505 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31506 PyObject *resultobj = 0;
31507 wxPyApp *result = 0 ;
31508
31509 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
31510 {
31511 PyThreadState* __tstate = wxPyBeginAllowThreads();
31512 result = (wxPyApp *)wxPyGetApp();
31513 wxPyEndAllowThreads(__tstate);
31514 if (PyErr_Occurred()) SWIG_fail;
31515 }
31516 {
31517 resultobj = wxPyMake_wxObject(result, 0);
31518 }
31519 return resultobj;
31520 fail:
31521 return NULL;
31522 }
31523
31524
31525 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31526 PyObject *resultobj = 0;
31527 char *arg1 = (char *) 0 ;
31528 int res1 ;
31529 char *buf1 = 0 ;
31530 int alloc1 = 0 ;
31531 PyObject * obj0 = 0 ;
31532 char * kwnames[] = {
31533 (char *) "encoding", NULL
31534 };
31535
31536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
31537 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
31538 if (!SWIG_IsOK(res1)) {
31539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
31540 }
31541 arg1 = buf1;
31542 {
31543 PyThreadState* __tstate = wxPyBeginAllowThreads();
31544 wxSetDefaultPyEncoding((char const *)arg1);
31545 wxPyEndAllowThreads(__tstate);
31546 if (PyErr_Occurred()) SWIG_fail;
31547 }
31548 resultobj = SWIG_Py_Void();
31549 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31550 return resultobj;
31551 fail:
31552 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31553 return NULL;
31554 }
31555
31556
31557 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31558 PyObject *resultobj = 0;
31559 char *result = 0 ;
31560
31561 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
31562 {
31563 PyThreadState* __tstate = wxPyBeginAllowThreads();
31564 result = (char *)wxGetDefaultPyEncoding();
31565 wxPyEndAllowThreads(__tstate);
31566 if (PyErr_Occurred()) SWIG_fail;
31567 }
31568 resultobj = SWIG_FromCharPtr(result);
31569 return resultobj;
31570 fail:
31571 return NULL;
31572 }
31573
31574
31575 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31576 PyObject *resultobj = 0;
31577 wxEventLoop *result = 0 ;
31578
31579 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
31580 {
31581 PyThreadState* __tstate = wxPyBeginAllowThreads();
31582 result = (wxEventLoop *)new wxEventLoop();
31583 wxPyEndAllowThreads(__tstate);
31584 if (PyErr_Occurred()) SWIG_fail;
31585 }
31586 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
31587 return resultobj;
31588 fail:
31589 return NULL;
31590 }
31591
31592
31593 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31594 PyObject *resultobj = 0;
31595 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31596 void *argp1 = 0 ;
31597 int res1 = 0 ;
31598 PyObject *swig_obj[1] ;
31599
31600 if (!args) SWIG_fail;
31601 swig_obj[0] = args;
31602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
31603 if (!SWIG_IsOK(res1)) {
31604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31605 }
31606 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31607 {
31608 PyThreadState* __tstate = wxPyBeginAllowThreads();
31609 delete arg1;
31610
31611 wxPyEndAllowThreads(__tstate);
31612 if (PyErr_Occurred()) SWIG_fail;
31613 }
31614 resultobj = SWIG_Py_Void();
31615 return resultobj;
31616 fail:
31617 return NULL;
31618 }
31619
31620
31621 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31622 PyObject *resultobj = 0;
31623 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31624 int result;
31625 void *argp1 = 0 ;
31626 int res1 = 0 ;
31627 PyObject *swig_obj[1] ;
31628
31629 if (!args) SWIG_fail;
31630 swig_obj[0] = args;
31631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31632 if (!SWIG_IsOK(res1)) {
31633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31634 }
31635 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31636 {
31637 PyThreadState* __tstate = wxPyBeginAllowThreads();
31638 result = (int)(arg1)->Run();
31639 wxPyEndAllowThreads(__tstate);
31640 if (PyErr_Occurred()) SWIG_fail;
31641 }
31642 resultobj = SWIG_From_int(static_cast< int >(result));
31643 return resultobj;
31644 fail:
31645 return NULL;
31646 }
31647
31648
31649 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31650 PyObject *resultobj = 0;
31651 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31652 int arg2 = (int) 0 ;
31653 void *argp1 = 0 ;
31654 int res1 = 0 ;
31655 int val2 ;
31656 int ecode2 = 0 ;
31657 PyObject * obj0 = 0 ;
31658 PyObject * obj1 = 0 ;
31659 char * kwnames[] = {
31660 (char *) "self",(char *) "rc", NULL
31661 };
31662
31663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
31664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31665 if (!SWIG_IsOK(res1)) {
31666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31667 }
31668 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31669 if (obj1) {
31670 ecode2 = SWIG_AsVal_int(obj1, &val2);
31671 if (!SWIG_IsOK(ecode2)) {
31672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
31673 }
31674 arg2 = static_cast< int >(val2);
31675 }
31676 {
31677 PyThreadState* __tstate = wxPyBeginAllowThreads();
31678 (arg1)->Exit(arg2);
31679 wxPyEndAllowThreads(__tstate);
31680 if (PyErr_Occurred()) SWIG_fail;
31681 }
31682 resultobj = SWIG_Py_Void();
31683 return resultobj;
31684 fail:
31685 return NULL;
31686 }
31687
31688
31689 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31690 PyObject *resultobj = 0;
31691 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31692 bool result;
31693 void *argp1 = 0 ;
31694 int res1 = 0 ;
31695 PyObject *swig_obj[1] ;
31696
31697 if (!args) SWIG_fail;
31698 swig_obj[0] = args;
31699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31700 if (!SWIG_IsOK(res1)) {
31701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31702 }
31703 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31704 {
31705 PyThreadState* __tstate = wxPyBeginAllowThreads();
31706 result = (bool)((wxEventLoop const *)arg1)->Pending();
31707 wxPyEndAllowThreads(__tstate);
31708 if (PyErr_Occurred()) SWIG_fail;
31709 }
31710 {
31711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31712 }
31713 return resultobj;
31714 fail:
31715 return NULL;
31716 }
31717
31718
31719 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31720 PyObject *resultobj = 0;
31721 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31722 bool result;
31723 void *argp1 = 0 ;
31724 int res1 = 0 ;
31725 PyObject *swig_obj[1] ;
31726
31727 if (!args) SWIG_fail;
31728 swig_obj[0] = args;
31729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31730 if (!SWIG_IsOK(res1)) {
31731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31732 }
31733 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31734 {
31735 PyThreadState* __tstate = wxPyBeginAllowThreads();
31736 result = (bool)(arg1)->Dispatch();
31737 wxPyEndAllowThreads(__tstate);
31738 if (PyErr_Occurred()) SWIG_fail;
31739 }
31740 {
31741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31742 }
31743 return resultobj;
31744 fail:
31745 return NULL;
31746 }
31747
31748
31749 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31750 PyObject *resultobj = 0;
31751 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31752 bool result;
31753 void *argp1 = 0 ;
31754 int res1 = 0 ;
31755 PyObject *swig_obj[1] ;
31756
31757 if (!args) SWIG_fail;
31758 swig_obj[0] = args;
31759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31760 if (!SWIG_IsOK(res1)) {
31761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31762 }
31763 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31764 {
31765 PyThreadState* __tstate = wxPyBeginAllowThreads();
31766 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
31767 wxPyEndAllowThreads(__tstate);
31768 if (PyErr_Occurred()) SWIG_fail;
31769 }
31770 {
31771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31772 }
31773 return resultobj;
31774 fail:
31775 return NULL;
31776 }
31777
31778
31779 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31780 PyObject *resultobj = 0;
31781 wxEventLoop *result = 0 ;
31782
31783 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
31784 {
31785 PyThreadState* __tstate = wxPyBeginAllowThreads();
31786 result = (wxEventLoop *)wxEventLoop::GetActive();
31787 wxPyEndAllowThreads(__tstate);
31788 if (PyErr_Occurred()) SWIG_fail;
31789 }
31790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
31791 return resultobj;
31792 fail:
31793 return NULL;
31794 }
31795
31796
31797 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31798 PyObject *resultobj = 0;
31799 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31800 void *argp1 = 0 ;
31801 int res1 = 0 ;
31802 PyObject * obj0 = 0 ;
31803 char * kwnames[] = {
31804 (char *) "loop", NULL
31805 };
31806
31807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
31808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31809 if (!SWIG_IsOK(res1)) {
31810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31811 }
31812 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31813 {
31814 PyThreadState* __tstate = wxPyBeginAllowThreads();
31815 wxEventLoop::SetActive(arg1);
31816 wxPyEndAllowThreads(__tstate);
31817 if (PyErr_Occurred()) SWIG_fail;
31818 }
31819 resultobj = SWIG_Py_Void();
31820 return resultobj;
31821 fail:
31822 return NULL;
31823 }
31824
31825
31826 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31827 PyObject *obj;
31828 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31829 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
31830 return SWIG_Py_Void();
31831 }
31832
31833 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31834 return SWIG_Python_InitShadowInstance(args);
31835 }
31836
31837 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31838 PyObject *resultobj = 0;
31839 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31840 wxEventLoopActivator *result = 0 ;
31841 void *argp1 = 0 ;
31842 int res1 = 0 ;
31843 PyObject * obj0 = 0 ;
31844 char * kwnames[] = {
31845 (char *) "evtLoop", NULL
31846 };
31847
31848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
31849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31850 if (!SWIG_IsOK(res1)) {
31851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31852 }
31853 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31854 {
31855 PyThreadState* __tstate = wxPyBeginAllowThreads();
31856 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
31857 wxPyEndAllowThreads(__tstate);
31858 if (PyErr_Occurred()) SWIG_fail;
31859 }
31860 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
31861 return resultobj;
31862 fail:
31863 return NULL;
31864 }
31865
31866
31867 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31868 PyObject *resultobj = 0;
31869 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
31870 void *argp1 = 0 ;
31871 int res1 = 0 ;
31872 PyObject *swig_obj[1] ;
31873
31874 if (!args) SWIG_fail;
31875 swig_obj[0] = args;
31876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
31877 if (!SWIG_IsOK(res1)) {
31878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
31879 }
31880 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
31881 {
31882 PyThreadState* __tstate = wxPyBeginAllowThreads();
31883 delete arg1;
31884
31885 wxPyEndAllowThreads(__tstate);
31886 if (PyErr_Occurred()) SWIG_fail;
31887 }
31888 resultobj = SWIG_Py_Void();
31889 return resultobj;
31890 fail:
31891 return NULL;
31892 }
31893
31894
31895 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31896 PyObject *obj;
31897 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31898 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
31899 return SWIG_Py_Void();
31900 }
31901
31902 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31903 return SWIG_Python_InitShadowInstance(args);
31904 }
31905
31906 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31907 PyObject *resultobj = 0;
31908 int arg1 = (int) 0 ;
31909 int arg2 = (int) 0 ;
31910 int arg3 = (int) 0 ;
31911 wxAcceleratorEntry *result = 0 ;
31912 int val1 ;
31913 int ecode1 = 0 ;
31914 int val2 ;
31915 int ecode2 = 0 ;
31916 int val3 ;
31917 int ecode3 = 0 ;
31918 PyObject * obj0 = 0 ;
31919 PyObject * obj1 = 0 ;
31920 PyObject * obj2 = 0 ;
31921 char * kwnames[] = {
31922 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
31923 };
31924
31925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31926 if (obj0) {
31927 ecode1 = SWIG_AsVal_int(obj0, &val1);
31928 if (!SWIG_IsOK(ecode1)) {
31929 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
31930 }
31931 arg1 = static_cast< int >(val1);
31932 }
31933 if (obj1) {
31934 ecode2 = SWIG_AsVal_int(obj1, &val2);
31935 if (!SWIG_IsOK(ecode2)) {
31936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
31937 }
31938 arg2 = static_cast< int >(val2);
31939 }
31940 if (obj2) {
31941 ecode3 = SWIG_AsVal_int(obj2, &val3);
31942 if (!SWIG_IsOK(ecode3)) {
31943 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
31944 }
31945 arg3 = static_cast< int >(val3);
31946 }
31947 {
31948 PyThreadState* __tstate = wxPyBeginAllowThreads();
31949 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
31950 wxPyEndAllowThreads(__tstate);
31951 if (PyErr_Occurred()) SWIG_fail;
31952 }
31953 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
31954 return resultobj;
31955 fail:
31956 return NULL;
31957 }
31958
31959
31960 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31961 PyObject *resultobj = 0;
31962 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
31963 void *argp1 = 0 ;
31964 int res1 = 0 ;
31965 PyObject *swig_obj[1] ;
31966
31967 if (!args) SWIG_fail;
31968 swig_obj[0] = args;
31969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
31970 if (!SWIG_IsOK(res1)) {
31971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
31972 }
31973 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
31974 {
31975 PyThreadState* __tstate = wxPyBeginAllowThreads();
31976 delete arg1;
31977
31978 wxPyEndAllowThreads(__tstate);
31979 if (PyErr_Occurred()) SWIG_fail;
31980 }
31981 resultobj = SWIG_Py_Void();
31982 return resultobj;
31983 fail:
31984 return NULL;
31985 }
31986
31987
31988 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31989 PyObject *resultobj = 0;
31990 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
31991 int arg2 ;
31992 int arg3 ;
31993 int arg4 ;
31994 void *argp1 = 0 ;
31995 int res1 = 0 ;
31996 int val2 ;
31997 int ecode2 = 0 ;
31998 int val3 ;
31999 int ecode3 = 0 ;
32000 int val4 ;
32001 int ecode4 = 0 ;
32002 PyObject * obj0 = 0 ;
32003 PyObject * obj1 = 0 ;
32004 PyObject * obj2 = 0 ;
32005 PyObject * obj3 = 0 ;
32006 char * kwnames[] = {
32007 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
32008 };
32009
32010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32012 if (!SWIG_IsOK(res1)) {
32013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32014 }
32015 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32016 ecode2 = SWIG_AsVal_int(obj1, &val2);
32017 if (!SWIG_IsOK(ecode2)) {
32018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
32019 }
32020 arg2 = static_cast< int >(val2);
32021 ecode3 = SWIG_AsVal_int(obj2, &val3);
32022 if (!SWIG_IsOK(ecode3)) {
32023 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
32024 }
32025 arg3 = static_cast< int >(val3);
32026 ecode4 = SWIG_AsVal_int(obj3, &val4);
32027 if (!SWIG_IsOK(ecode4)) {
32028 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
32029 }
32030 arg4 = static_cast< int >(val4);
32031 {
32032 PyThreadState* __tstate = wxPyBeginAllowThreads();
32033 (arg1)->Set(arg2,arg3,arg4);
32034 wxPyEndAllowThreads(__tstate);
32035 if (PyErr_Occurred()) SWIG_fail;
32036 }
32037 resultobj = SWIG_Py_Void();
32038 return resultobj;
32039 fail:
32040 return NULL;
32041 }
32042
32043
32044 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32045 PyObject *resultobj = 0;
32046 wxString *arg1 = 0 ;
32047 wxAcceleratorEntry *result = 0 ;
32048 bool temp1 = false ;
32049 PyObject * obj0 = 0 ;
32050 char * kwnames[] = {
32051 (char *) "str", NULL
32052 };
32053
32054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
32055 {
32056 arg1 = wxString_in_helper(obj0);
32057 if (arg1 == NULL) SWIG_fail;
32058 temp1 = true;
32059 }
32060 {
32061 PyThreadState* __tstate = wxPyBeginAllowThreads();
32062 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
32063 wxPyEndAllowThreads(__tstate);
32064 if (PyErr_Occurred()) SWIG_fail;
32065 }
32066 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
32067 {
32068 if (temp1)
32069 delete arg1;
32070 }
32071 return resultobj;
32072 fail:
32073 {
32074 if (temp1)
32075 delete arg1;
32076 }
32077 return NULL;
32078 }
32079
32080
32081 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32082 PyObject *resultobj = 0;
32083 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32084 int result;
32085 void *argp1 = 0 ;
32086 int res1 = 0 ;
32087 PyObject *swig_obj[1] ;
32088
32089 if (!args) SWIG_fail;
32090 swig_obj[0] = args;
32091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32092 if (!SWIG_IsOK(res1)) {
32093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32094 }
32095 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32096 {
32097 PyThreadState* __tstate = wxPyBeginAllowThreads();
32098 result = (int)(arg1)->GetFlags();
32099 wxPyEndAllowThreads(__tstate);
32100 if (PyErr_Occurred()) SWIG_fail;
32101 }
32102 resultobj = SWIG_From_int(static_cast< int >(result));
32103 return resultobj;
32104 fail:
32105 return NULL;
32106 }
32107
32108
32109 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32110 PyObject *resultobj = 0;
32111 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32112 int result;
32113 void *argp1 = 0 ;
32114 int res1 = 0 ;
32115 PyObject *swig_obj[1] ;
32116
32117 if (!args) SWIG_fail;
32118 swig_obj[0] = args;
32119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32120 if (!SWIG_IsOK(res1)) {
32121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32122 }
32123 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32124 {
32125 PyThreadState* __tstate = wxPyBeginAllowThreads();
32126 result = (int)(arg1)->GetKeyCode();
32127 wxPyEndAllowThreads(__tstate);
32128 if (PyErr_Occurred()) SWIG_fail;
32129 }
32130 resultobj = SWIG_From_int(static_cast< int >(result));
32131 return resultobj;
32132 fail:
32133 return NULL;
32134 }
32135
32136
32137 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32138 PyObject *resultobj = 0;
32139 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32140 int result;
32141 void *argp1 = 0 ;
32142 int res1 = 0 ;
32143 PyObject *swig_obj[1] ;
32144
32145 if (!args) SWIG_fail;
32146 swig_obj[0] = args;
32147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32148 if (!SWIG_IsOK(res1)) {
32149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32150 }
32151 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32152 {
32153 PyThreadState* __tstate = wxPyBeginAllowThreads();
32154 result = (int)(arg1)->GetCommand();
32155 wxPyEndAllowThreads(__tstate);
32156 if (PyErr_Occurred()) SWIG_fail;
32157 }
32158 resultobj = SWIG_From_int(static_cast< int >(result));
32159 return resultobj;
32160 fail:
32161 return NULL;
32162 }
32163
32164
32165 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32166 PyObject *resultobj = 0;
32167 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32168 bool result;
32169 void *argp1 = 0 ;
32170 int res1 = 0 ;
32171 PyObject *swig_obj[1] ;
32172
32173 if (!args) SWIG_fail;
32174 swig_obj[0] = args;
32175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32176 if (!SWIG_IsOK(res1)) {
32177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32178 }
32179 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32180 {
32181 PyThreadState* __tstate = wxPyBeginAllowThreads();
32182 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
32183 wxPyEndAllowThreads(__tstate);
32184 if (PyErr_Occurred()) SWIG_fail;
32185 }
32186 {
32187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32188 }
32189 return resultobj;
32190 fail:
32191 return NULL;
32192 }
32193
32194
32195 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32196 PyObject *resultobj = 0;
32197 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32198 wxString result;
32199 void *argp1 = 0 ;
32200 int res1 = 0 ;
32201 PyObject *swig_obj[1] ;
32202
32203 if (!args) SWIG_fail;
32204 swig_obj[0] = args;
32205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32206 if (!SWIG_IsOK(res1)) {
32207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32208 }
32209 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32210 {
32211 PyThreadState* __tstate = wxPyBeginAllowThreads();
32212 result = ((wxAcceleratorEntry const *)arg1)->ToString();
32213 wxPyEndAllowThreads(__tstate);
32214 if (PyErr_Occurred()) SWIG_fail;
32215 }
32216 {
32217 #if wxUSE_UNICODE
32218 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32219 #else
32220 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32221 #endif
32222 }
32223 return resultobj;
32224 fail:
32225 return NULL;
32226 }
32227
32228
32229 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32230 PyObject *resultobj = 0;
32231 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32232 wxString *arg2 = 0 ;
32233 bool result;
32234 void *argp1 = 0 ;
32235 int res1 = 0 ;
32236 bool temp2 = false ;
32237 PyObject * obj0 = 0 ;
32238 PyObject * obj1 = 0 ;
32239 char * kwnames[] = {
32240 (char *) "self",(char *) "str", NULL
32241 };
32242
32243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
32244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32245 if (!SWIG_IsOK(res1)) {
32246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32247 }
32248 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32249 {
32250 arg2 = wxString_in_helper(obj1);
32251 if (arg2 == NULL) SWIG_fail;
32252 temp2 = true;
32253 }
32254 {
32255 PyThreadState* __tstate = wxPyBeginAllowThreads();
32256 result = (bool)(arg1)->FromString((wxString const &)*arg2);
32257 wxPyEndAllowThreads(__tstate);
32258 if (PyErr_Occurred()) SWIG_fail;
32259 }
32260 {
32261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32262 }
32263 {
32264 if (temp2)
32265 delete arg2;
32266 }
32267 return resultobj;
32268 fail:
32269 {
32270 if (temp2)
32271 delete arg2;
32272 }
32273 return NULL;
32274 }
32275
32276
32277 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32278 PyObject *obj;
32279 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32280 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
32281 return SWIG_Py_Void();
32282 }
32283
32284 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32285 return SWIG_Python_InitShadowInstance(args);
32286 }
32287
32288 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32289 PyObject *resultobj = 0;
32290 int arg1 ;
32291 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
32292 wxAcceleratorTable *result = 0 ;
32293 PyObject * obj0 = 0 ;
32294 char * kwnames[] = {
32295 (char *) "n", NULL
32296 };
32297
32298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
32299 {
32300 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
32301 if (arg2) arg1 = PyList_Size(obj0);
32302 else arg1 = 0;
32303 }
32304 {
32305 PyThreadState* __tstate = wxPyBeginAllowThreads();
32306 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
32307 wxPyEndAllowThreads(__tstate);
32308 if (PyErr_Occurred()) SWIG_fail;
32309 }
32310 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
32311 return resultobj;
32312 fail:
32313 return NULL;
32314 }
32315
32316
32317 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32318 PyObject *resultobj = 0;
32319 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32320 void *argp1 = 0 ;
32321 int res1 = 0 ;
32322 PyObject *swig_obj[1] ;
32323
32324 if (!args) SWIG_fail;
32325 swig_obj[0] = args;
32326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
32327 if (!SWIG_IsOK(res1)) {
32328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
32329 }
32330 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32331 {
32332 PyThreadState* __tstate = wxPyBeginAllowThreads();
32333 delete arg1;
32334
32335 wxPyEndAllowThreads(__tstate);
32336 if (PyErr_Occurred()) SWIG_fail;
32337 }
32338 resultobj = SWIG_Py_Void();
32339 return resultobj;
32340 fail:
32341 return NULL;
32342 }
32343
32344
32345 SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32346 PyObject *resultobj = 0;
32347 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32348 bool result;
32349 void *argp1 = 0 ;
32350 int res1 = 0 ;
32351 PyObject *swig_obj[1] ;
32352
32353 if (!args) SWIG_fail;
32354 swig_obj[0] = args;
32355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
32356 if (!SWIG_IsOK(res1)) {
32357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
32358 }
32359 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32360 {
32361 PyThreadState* __tstate = wxPyBeginAllowThreads();
32362 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
32363 wxPyEndAllowThreads(__tstate);
32364 if (PyErr_Occurred()) SWIG_fail;
32365 }
32366 {
32367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32368 }
32369 return resultobj;
32370 fail:
32371 return NULL;
32372 }
32373
32374
32375 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32376 PyObject *obj;
32377 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32378 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
32379 return SWIG_Py_Void();
32380 }
32381
32382 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32383 return SWIG_Python_InitShadowInstance(args);
32384 }
32385
32386 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
32387 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
32388 return 1;
32389 }
32390
32391
32392 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
32393 PyObject *pyobj = 0;
32394
32395 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
32396 return pyobj;
32397 }
32398
32399
32400 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32401 PyObject *resultobj = 0;
32402 wxString *arg1 = 0 ;
32403 wxAcceleratorEntry *result = 0 ;
32404 bool temp1 = false ;
32405 PyObject * obj0 = 0 ;
32406 char * kwnames[] = {
32407 (char *) "label", NULL
32408 };
32409
32410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
32411 {
32412 arg1 = wxString_in_helper(obj0);
32413 if (arg1 == NULL) SWIG_fail;
32414 temp1 = true;
32415 }
32416 {
32417 PyThreadState* __tstate = wxPyBeginAllowThreads();
32418 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
32419 wxPyEndAllowThreads(__tstate);
32420 if (PyErr_Occurred()) SWIG_fail;
32421 }
32422 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32423 {
32424 if (temp1)
32425 delete arg1;
32426 }
32427 return resultobj;
32428 fail:
32429 {
32430 if (temp1)
32431 delete arg1;
32432 }
32433 return NULL;
32434 }
32435
32436
32437 SWIGINTERN int PanelNameStr_set(PyObject *) {
32438 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
32439 return 1;
32440 }
32441
32442
32443 SWIGINTERN PyObject *PanelNameStr_get(void) {
32444 PyObject *pyobj = 0;
32445
32446 {
32447 #if wxUSE_UNICODE
32448 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32449 #else
32450 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32451 #endif
32452 }
32453 return pyobj;
32454 }
32455
32456
32457 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32458 PyObject *resultobj = 0;
32459 wxVisualAttributes *result = 0 ;
32460
32461 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
32462 {
32463 PyThreadState* __tstate = wxPyBeginAllowThreads();
32464 result = (wxVisualAttributes *)new_wxVisualAttributes();
32465 wxPyEndAllowThreads(__tstate);
32466 if (PyErr_Occurred()) SWIG_fail;
32467 }
32468 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
32469 return resultobj;
32470 fail:
32471 return NULL;
32472 }
32473
32474
32475 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32476 PyObject *resultobj = 0;
32477 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32478 void *argp1 = 0 ;
32479 int res1 = 0 ;
32480 PyObject *swig_obj[1] ;
32481
32482 if (!args) SWIG_fail;
32483 swig_obj[0] = args;
32484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
32485 if (!SWIG_IsOK(res1)) {
32486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32487 }
32488 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32489 {
32490 PyThreadState* __tstate = wxPyBeginAllowThreads();
32491 delete_wxVisualAttributes(arg1);
32492
32493 wxPyEndAllowThreads(__tstate);
32494 if (PyErr_Occurred()) SWIG_fail;
32495 }
32496 resultobj = SWIG_Py_Void();
32497 return resultobj;
32498 fail:
32499 return NULL;
32500 }
32501
32502
32503 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32504 PyObject *resultobj = 0;
32505 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32506 wxFont *arg2 = (wxFont *) 0 ;
32507 void *argp1 = 0 ;
32508 int res1 = 0 ;
32509 void *argp2 = 0 ;
32510 int res2 = 0 ;
32511 PyObject *swig_obj[2] ;
32512
32513 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
32514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32515 if (!SWIG_IsOK(res1)) {
32516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32517 }
32518 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32519 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
32520 if (!SWIG_IsOK(res2)) {
32521 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
32522 }
32523 arg2 = reinterpret_cast< wxFont * >(argp2);
32524 if (arg1) (arg1)->font = *arg2;
32525
32526 resultobj = SWIG_Py_Void();
32527 return resultobj;
32528 fail:
32529 return NULL;
32530 }
32531
32532
32533 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32534 PyObject *resultobj = 0;
32535 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32536 wxFont *result = 0 ;
32537 void *argp1 = 0 ;
32538 int res1 = 0 ;
32539 PyObject *swig_obj[1] ;
32540
32541 if (!args) SWIG_fail;
32542 swig_obj[0] = args;
32543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32544 if (!SWIG_IsOK(res1)) {
32545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32546 }
32547 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32548 result = (wxFont *)& ((arg1)->font);
32549 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
32550 return resultobj;
32551 fail:
32552 return NULL;
32553 }
32554
32555
32556 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32557 PyObject *resultobj = 0;
32558 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32559 wxColour *arg2 = (wxColour *) 0 ;
32560 void *argp1 = 0 ;
32561 int res1 = 0 ;
32562 void *argp2 = 0 ;
32563 int res2 = 0 ;
32564 PyObject *swig_obj[2] ;
32565
32566 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
32567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32568 if (!SWIG_IsOK(res1)) {
32569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32570 }
32571 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32572 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32573 if (!SWIG_IsOK(res2)) {
32574 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32575 }
32576 arg2 = reinterpret_cast< wxColour * >(argp2);
32577 if (arg1) (arg1)->colFg = *arg2;
32578
32579 resultobj = SWIG_Py_Void();
32580 return resultobj;
32581 fail:
32582 return NULL;
32583 }
32584
32585
32586 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32587 PyObject *resultobj = 0;
32588 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32589 wxColour *result = 0 ;
32590 void *argp1 = 0 ;
32591 int res1 = 0 ;
32592 PyObject *swig_obj[1] ;
32593
32594 if (!args) SWIG_fail;
32595 swig_obj[0] = args;
32596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32597 if (!SWIG_IsOK(res1)) {
32598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32599 }
32600 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32601 result = (wxColour *)& ((arg1)->colFg);
32602 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32603 return resultobj;
32604 fail:
32605 return NULL;
32606 }
32607
32608
32609 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32610 PyObject *resultobj = 0;
32611 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32612 wxColour *arg2 = (wxColour *) 0 ;
32613 void *argp1 = 0 ;
32614 int res1 = 0 ;
32615 void *argp2 = 0 ;
32616 int res2 = 0 ;
32617 PyObject *swig_obj[2] ;
32618
32619 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
32620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32621 if (!SWIG_IsOK(res1)) {
32622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32623 }
32624 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32625 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32626 if (!SWIG_IsOK(res2)) {
32627 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32628 }
32629 arg2 = reinterpret_cast< wxColour * >(argp2);
32630 if (arg1) (arg1)->colBg = *arg2;
32631
32632 resultobj = SWIG_Py_Void();
32633 return resultobj;
32634 fail:
32635 return NULL;
32636 }
32637
32638
32639 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32640 PyObject *resultobj = 0;
32641 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32642 wxColour *result = 0 ;
32643 void *argp1 = 0 ;
32644 int res1 = 0 ;
32645 PyObject *swig_obj[1] ;
32646
32647 if (!args) SWIG_fail;
32648 swig_obj[0] = args;
32649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32650 if (!SWIG_IsOK(res1)) {
32651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32652 }
32653 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32654 result = (wxColour *)& ((arg1)->colBg);
32655 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32656 return resultobj;
32657 fail:
32658 return NULL;
32659 }
32660
32661
32662 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32663 PyObject *obj;
32664 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32665 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
32666 return SWIG_Py_Void();
32667 }
32668
32669 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32670 return SWIG_Python_InitShadowInstance(args);
32671 }
32672
32673 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32674 PyObject *resultobj = 0;
32675 wxWindow *arg1 = (wxWindow *) 0 ;
32676 int arg2 = (int) (int)-1 ;
32677 wxPoint const &arg3_defvalue = wxDefaultPosition ;
32678 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
32679 wxSize const &arg4_defvalue = wxDefaultSize ;
32680 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32681 long arg5 = (long) 0 ;
32682 wxString const &arg6_defvalue = wxPyPanelNameStr ;
32683 wxString *arg6 = (wxString *) &arg6_defvalue ;
32684 wxWindow *result = 0 ;
32685 void *argp1 = 0 ;
32686 int res1 = 0 ;
32687 int val2 ;
32688 int ecode2 = 0 ;
32689 wxPoint temp3 ;
32690 wxSize temp4 ;
32691 long val5 ;
32692 int ecode5 = 0 ;
32693 bool temp6 = false ;
32694 PyObject * obj0 = 0 ;
32695 PyObject * obj1 = 0 ;
32696 PyObject * obj2 = 0 ;
32697 PyObject * obj3 = 0 ;
32698 PyObject * obj4 = 0 ;
32699 PyObject * obj5 = 0 ;
32700 char * kwnames[] = {
32701 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32702 };
32703
32704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
32705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32706 if (!SWIG_IsOK(res1)) {
32707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
32708 }
32709 arg1 = reinterpret_cast< wxWindow * >(argp1);
32710 if (obj1) {
32711 ecode2 = SWIG_AsVal_int(obj1, &val2);
32712 if (!SWIG_IsOK(ecode2)) {
32713 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
32714 }
32715 arg2 = static_cast< int >(val2);
32716 }
32717 if (obj2) {
32718 {
32719 arg3 = &temp3;
32720 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
32721 }
32722 }
32723 if (obj3) {
32724 {
32725 arg4 = &temp4;
32726 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32727 }
32728 }
32729 if (obj4) {
32730 ecode5 = SWIG_AsVal_long(obj4, &val5);
32731 if (!SWIG_IsOK(ecode5)) {
32732 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
32733 }
32734 arg5 = static_cast< long >(val5);
32735 }
32736 if (obj5) {
32737 {
32738 arg6 = wxString_in_helper(obj5);
32739 if (arg6 == NULL) SWIG_fail;
32740 temp6 = true;
32741 }
32742 }
32743 {
32744 if (!wxPyCheckForApp()) SWIG_fail;
32745 PyThreadState* __tstate = wxPyBeginAllowThreads();
32746 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
32747 wxPyEndAllowThreads(__tstate);
32748 if (PyErr_Occurred()) SWIG_fail;
32749 }
32750 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
32751 {
32752 if (temp6)
32753 delete arg6;
32754 }
32755 return resultobj;
32756 fail:
32757 {
32758 if (temp6)
32759 delete arg6;
32760 }
32761 return NULL;
32762 }
32763
32764
32765 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32766 PyObject *resultobj = 0;
32767 wxWindow *result = 0 ;
32768
32769 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
32770 {
32771 if (!wxPyCheckForApp()) SWIG_fail;
32772 PyThreadState* __tstate = wxPyBeginAllowThreads();
32773 result = (wxWindow *)new wxWindow();
32774 wxPyEndAllowThreads(__tstate);
32775 if (PyErr_Occurred()) SWIG_fail;
32776 }
32777 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
32778 return resultobj;
32779 fail:
32780 return NULL;
32781 }
32782
32783
32784 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32785 PyObject *resultobj = 0;
32786 wxWindow *arg1 = (wxWindow *) 0 ;
32787 wxWindow *arg2 = (wxWindow *) 0 ;
32788 int arg3 = (int) (int)-1 ;
32789 wxPoint const &arg4_defvalue = wxDefaultPosition ;
32790 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
32791 wxSize const &arg5_defvalue = wxDefaultSize ;
32792 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
32793 long arg6 = (long) 0 ;
32794 wxString const &arg7_defvalue = wxPyPanelNameStr ;
32795 wxString *arg7 = (wxString *) &arg7_defvalue ;
32796 bool result;
32797 void *argp1 = 0 ;
32798 int res1 = 0 ;
32799 void *argp2 = 0 ;
32800 int res2 = 0 ;
32801 int val3 ;
32802 int ecode3 = 0 ;
32803 wxPoint temp4 ;
32804 wxSize temp5 ;
32805 long val6 ;
32806 int ecode6 = 0 ;
32807 bool temp7 = false ;
32808 PyObject * obj0 = 0 ;
32809 PyObject * obj1 = 0 ;
32810 PyObject * obj2 = 0 ;
32811 PyObject * obj3 = 0 ;
32812 PyObject * obj4 = 0 ;
32813 PyObject * obj5 = 0 ;
32814 PyObject * obj6 = 0 ;
32815 char * kwnames[] = {
32816 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32817 };
32818
32819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32821 if (!SWIG_IsOK(res1)) {
32822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
32823 }
32824 arg1 = reinterpret_cast< wxWindow * >(argp1);
32825 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32826 if (!SWIG_IsOK(res2)) {
32827 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
32828 }
32829 arg2 = reinterpret_cast< wxWindow * >(argp2);
32830 if (obj2) {
32831 ecode3 = SWIG_AsVal_int(obj2, &val3);
32832 if (!SWIG_IsOK(ecode3)) {
32833 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
32834 }
32835 arg3 = static_cast< int >(val3);
32836 }
32837 if (obj3) {
32838 {
32839 arg4 = &temp4;
32840 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
32841 }
32842 }
32843 if (obj4) {
32844 {
32845 arg5 = &temp5;
32846 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
32847 }
32848 }
32849 if (obj5) {
32850 ecode6 = SWIG_AsVal_long(obj5, &val6);
32851 if (!SWIG_IsOK(ecode6)) {
32852 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
32853 }
32854 arg6 = static_cast< long >(val6);
32855 }
32856 if (obj6) {
32857 {
32858 arg7 = wxString_in_helper(obj6);
32859 if (arg7 == NULL) SWIG_fail;
32860 temp7 = true;
32861 }
32862 }
32863 {
32864 PyThreadState* __tstate = wxPyBeginAllowThreads();
32865 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
32866 wxPyEndAllowThreads(__tstate);
32867 if (PyErr_Occurred()) SWIG_fail;
32868 }
32869 {
32870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32871 }
32872 {
32873 if (temp7)
32874 delete arg7;
32875 }
32876 return resultobj;
32877 fail:
32878 {
32879 if (temp7)
32880 delete arg7;
32881 }
32882 return NULL;
32883 }
32884
32885
32886 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32887 PyObject *resultobj = 0;
32888 wxWindow *arg1 = (wxWindow *) 0 ;
32889 bool arg2 = (bool) false ;
32890 bool result;
32891 void *argp1 = 0 ;
32892 int res1 = 0 ;
32893 bool val2 ;
32894 int ecode2 = 0 ;
32895 PyObject * obj0 = 0 ;
32896 PyObject * obj1 = 0 ;
32897 char * kwnames[] = {
32898 (char *) "self",(char *) "force", NULL
32899 };
32900
32901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
32902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32903 if (!SWIG_IsOK(res1)) {
32904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
32905 }
32906 arg1 = reinterpret_cast< wxWindow * >(argp1);
32907 if (obj1) {
32908 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32909 if (!SWIG_IsOK(ecode2)) {
32910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
32911 }
32912 arg2 = static_cast< bool >(val2);
32913 }
32914 {
32915 PyThreadState* __tstate = wxPyBeginAllowThreads();
32916 result = (bool)(arg1)->Close(arg2);
32917 wxPyEndAllowThreads(__tstate);
32918 if (PyErr_Occurred()) SWIG_fail;
32919 }
32920 {
32921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32922 }
32923 return resultobj;
32924 fail:
32925 return NULL;
32926 }
32927
32928
32929 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32930 PyObject *resultobj = 0;
32931 wxWindow *arg1 = (wxWindow *) 0 ;
32932 bool result;
32933 void *argp1 = 0 ;
32934 int res1 = 0 ;
32935 PyObject *swig_obj[1] ;
32936
32937 if (!args) SWIG_fail;
32938 swig_obj[0] = args;
32939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32940 if (!SWIG_IsOK(res1)) {
32941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
32942 }
32943 arg1 = reinterpret_cast< wxWindow * >(argp1);
32944 {
32945 PyThreadState* __tstate = wxPyBeginAllowThreads();
32946 result = (bool)(arg1)->Destroy();
32947 wxPyEndAllowThreads(__tstate);
32948 if (PyErr_Occurred()) SWIG_fail;
32949 }
32950 {
32951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32952 }
32953 return resultobj;
32954 fail:
32955 return NULL;
32956 }
32957
32958
32959 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32960 PyObject *resultobj = 0;
32961 wxWindow *arg1 = (wxWindow *) 0 ;
32962 bool result;
32963 void *argp1 = 0 ;
32964 int res1 = 0 ;
32965 PyObject *swig_obj[1] ;
32966
32967 if (!args) SWIG_fail;
32968 swig_obj[0] = args;
32969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32970 if (!SWIG_IsOK(res1)) {
32971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
32972 }
32973 arg1 = reinterpret_cast< wxWindow * >(argp1);
32974 {
32975 PyThreadState* __tstate = wxPyBeginAllowThreads();
32976 result = (bool)(arg1)->DestroyChildren();
32977 wxPyEndAllowThreads(__tstate);
32978 if (PyErr_Occurred()) SWIG_fail;
32979 }
32980 {
32981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32982 }
32983 return resultobj;
32984 fail:
32985 return NULL;
32986 }
32987
32988
32989 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32990 PyObject *resultobj = 0;
32991 wxWindow *arg1 = (wxWindow *) 0 ;
32992 bool result;
32993 void *argp1 = 0 ;
32994 int res1 = 0 ;
32995 PyObject *swig_obj[1] ;
32996
32997 if (!args) SWIG_fail;
32998 swig_obj[0] = args;
32999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33000 if (!SWIG_IsOK(res1)) {
33001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
33002 }
33003 arg1 = reinterpret_cast< wxWindow * >(argp1);
33004 {
33005 PyThreadState* __tstate = wxPyBeginAllowThreads();
33006 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
33007 wxPyEndAllowThreads(__tstate);
33008 if (PyErr_Occurred()) SWIG_fail;
33009 }
33010 {
33011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33012 }
33013 return resultobj;
33014 fail:
33015 return NULL;
33016 }
33017
33018
33019 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33020 PyObject *resultobj = 0;
33021 wxWindow *arg1 = (wxWindow *) 0 ;
33022 wxString *arg2 = 0 ;
33023 void *argp1 = 0 ;
33024 int res1 = 0 ;
33025 bool temp2 = false ;
33026 PyObject * obj0 = 0 ;
33027 PyObject * obj1 = 0 ;
33028 char * kwnames[] = {
33029 (char *) "self",(char *) "label", NULL
33030 };
33031
33032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
33033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33034 if (!SWIG_IsOK(res1)) {
33035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
33036 }
33037 arg1 = reinterpret_cast< wxWindow * >(argp1);
33038 {
33039 arg2 = wxString_in_helper(obj1);
33040 if (arg2 == NULL) SWIG_fail;
33041 temp2 = true;
33042 }
33043 {
33044 PyThreadState* __tstate = wxPyBeginAllowThreads();
33045 (arg1)->SetLabel((wxString const &)*arg2);
33046 wxPyEndAllowThreads(__tstate);
33047 if (PyErr_Occurred()) SWIG_fail;
33048 }
33049 resultobj = SWIG_Py_Void();
33050 {
33051 if (temp2)
33052 delete arg2;
33053 }
33054 return resultobj;
33055 fail:
33056 {
33057 if (temp2)
33058 delete arg2;
33059 }
33060 return NULL;
33061 }
33062
33063
33064 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33065 PyObject *resultobj = 0;
33066 wxWindow *arg1 = (wxWindow *) 0 ;
33067 wxString result;
33068 void *argp1 = 0 ;
33069 int res1 = 0 ;
33070 PyObject *swig_obj[1] ;
33071
33072 if (!args) SWIG_fail;
33073 swig_obj[0] = args;
33074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33075 if (!SWIG_IsOK(res1)) {
33076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33077 }
33078 arg1 = reinterpret_cast< wxWindow * >(argp1);
33079 {
33080 PyThreadState* __tstate = wxPyBeginAllowThreads();
33081 result = ((wxWindow const *)arg1)->GetLabel();
33082 wxPyEndAllowThreads(__tstate);
33083 if (PyErr_Occurred()) SWIG_fail;
33084 }
33085 {
33086 #if wxUSE_UNICODE
33087 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33088 #else
33089 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33090 #endif
33091 }
33092 return resultobj;
33093 fail:
33094 return NULL;
33095 }
33096
33097
33098 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33099 PyObject *resultobj = 0;
33100 wxWindow *arg1 = (wxWindow *) 0 ;
33101 wxString *arg2 = 0 ;
33102 void *argp1 = 0 ;
33103 int res1 = 0 ;
33104 bool temp2 = false ;
33105 PyObject * obj0 = 0 ;
33106 PyObject * obj1 = 0 ;
33107 char * kwnames[] = {
33108 (char *) "self",(char *) "name", NULL
33109 };
33110
33111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
33112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33113 if (!SWIG_IsOK(res1)) {
33114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
33115 }
33116 arg1 = reinterpret_cast< wxWindow * >(argp1);
33117 {
33118 arg2 = wxString_in_helper(obj1);
33119 if (arg2 == NULL) SWIG_fail;
33120 temp2 = true;
33121 }
33122 {
33123 PyThreadState* __tstate = wxPyBeginAllowThreads();
33124 (arg1)->SetName((wxString const &)*arg2);
33125 wxPyEndAllowThreads(__tstate);
33126 if (PyErr_Occurred()) SWIG_fail;
33127 }
33128 resultobj = SWIG_Py_Void();
33129 {
33130 if (temp2)
33131 delete arg2;
33132 }
33133 return resultobj;
33134 fail:
33135 {
33136 if (temp2)
33137 delete arg2;
33138 }
33139 return NULL;
33140 }
33141
33142
33143 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33144 PyObject *resultobj = 0;
33145 wxWindow *arg1 = (wxWindow *) 0 ;
33146 wxString result;
33147 void *argp1 = 0 ;
33148 int res1 = 0 ;
33149 PyObject *swig_obj[1] ;
33150
33151 if (!args) SWIG_fail;
33152 swig_obj[0] = args;
33153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33154 if (!SWIG_IsOK(res1)) {
33155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
33156 }
33157 arg1 = reinterpret_cast< wxWindow * >(argp1);
33158 {
33159 PyThreadState* __tstate = wxPyBeginAllowThreads();
33160 result = ((wxWindow const *)arg1)->GetName();
33161 wxPyEndAllowThreads(__tstate);
33162 if (PyErr_Occurred()) SWIG_fail;
33163 }
33164 {
33165 #if wxUSE_UNICODE
33166 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33167 #else
33168 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33169 #endif
33170 }
33171 return resultobj;
33172 fail:
33173 return NULL;
33174 }
33175
33176
33177 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33178 PyObject *resultobj = 0;
33179 wxWindow *arg1 = (wxWindow *) 0 ;
33180 wxWindowVariant arg2 ;
33181 void *argp1 = 0 ;
33182 int res1 = 0 ;
33183 int val2 ;
33184 int ecode2 = 0 ;
33185 PyObject * obj0 = 0 ;
33186 PyObject * obj1 = 0 ;
33187 char * kwnames[] = {
33188 (char *) "self",(char *) "variant", NULL
33189 };
33190
33191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
33192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33193 if (!SWIG_IsOK(res1)) {
33194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
33195 }
33196 arg1 = reinterpret_cast< wxWindow * >(argp1);
33197 ecode2 = SWIG_AsVal_int(obj1, &val2);
33198 if (!SWIG_IsOK(ecode2)) {
33199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
33200 }
33201 arg2 = static_cast< wxWindowVariant >(val2);
33202 {
33203 PyThreadState* __tstate = wxPyBeginAllowThreads();
33204 (arg1)->SetWindowVariant(arg2);
33205 wxPyEndAllowThreads(__tstate);
33206 if (PyErr_Occurred()) SWIG_fail;
33207 }
33208 resultobj = SWIG_Py_Void();
33209 return resultobj;
33210 fail:
33211 return NULL;
33212 }
33213
33214
33215 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33216 PyObject *resultobj = 0;
33217 wxWindow *arg1 = (wxWindow *) 0 ;
33218 wxWindowVariant result;
33219 void *argp1 = 0 ;
33220 int res1 = 0 ;
33221 PyObject *swig_obj[1] ;
33222
33223 if (!args) SWIG_fail;
33224 swig_obj[0] = args;
33225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33226 if (!SWIG_IsOK(res1)) {
33227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
33228 }
33229 arg1 = reinterpret_cast< wxWindow * >(argp1);
33230 {
33231 PyThreadState* __tstate = wxPyBeginAllowThreads();
33232 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
33233 wxPyEndAllowThreads(__tstate);
33234 if (PyErr_Occurred()) SWIG_fail;
33235 }
33236 resultobj = SWIG_From_int(static_cast< int >(result));
33237 return resultobj;
33238 fail:
33239 return NULL;
33240 }
33241
33242
33243 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33244 PyObject *resultobj = 0;
33245 wxWindow *arg1 = (wxWindow *) 0 ;
33246 int arg2 ;
33247 void *argp1 = 0 ;
33248 int res1 = 0 ;
33249 int val2 ;
33250 int ecode2 = 0 ;
33251 PyObject * obj0 = 0 ;
33252 PyObject * obj1 = 0 ;
33253 char * kwnames[] = {
33254 (char *) "self",(char *) "winid", NULL
33255 };
33256
33257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
33258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33259 if (!SWIG_IsOK(res1)) {
33260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
33261 }
33262 arg1 = reinterpret_cast< wxWindow * >(argp1);
33263 ecode2 = SWIG_AsVal_int(obj1, &val2);
33264 if (!SWIG_IsOK(ecode2)) {
33265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
33266 }
33267 arg2 = static_cast< int >(val2);
33268 {
33269 PyThreadState* __tstate = wxPyBeginAllowThreads();
33270 (arg1)->SetId(arg2);
33271 wxPyEndAllowThreads(__tstate);
33272 if (PyErr_Occurred()) SWIG_fail;
33273 }
33274 resultobj = SWIG_Py_Void();
33275 return resultobj;
33276 fail:
33277 return NULL;
33278 }
33279
33280
33281 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33282 PyObject *resultobj = 0;
33283 wxWindow *arg1 = (wxWindow *) 0 ;
33284 int result;
33285 void *argp1 = 0 ;
33286 int res1 = 0 ;
33287 PyObject *swig_obj[1] ;
33288
33289 if (!args) SWIG_fail;
33290 swig_obj[0] = args;
33291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33292 if (!SWIG_IsOK(res1)) {
33293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
33294 }
33295 arg1 = reinterpret_cast< wxWindow * >(argp1);
33296 {
33297 PyThreadState* __tstate = wxPyBeginAllowThreads();
33298 result = (int)((wxWindow const *)arg1)->GetId();
33299 wxPyEndAllowThreads(__tstate);
33300 if (PyErr_Occurred()) SWIG_fail;
33301 }
33302 resultobj = SWIG_From_int(static_cast< int >(result));
33303 return resultobj;
33304 fail:
33305 return NULL;
33306 }
33307
33308
33309 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33310 PyObject *resultobj = 0;
33311 int result;
33312
33313 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
33314 {
33315 PyThreadState* __tstate = wxPyBeginAllowThreads();
33316 result = (int)wxWindow::NewControlId();
33317 wxPyEndAllowThreads(__tstate);
33318 if (PyErr_Occurred()) SWIG_fail;
33319 }
33320 resultobj = SWIG_From_int(static_cast< int >(result));
33321 return resultobj;
33322 fail:
33323 return NULL;
33324 }
33325
33326
33327 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33328 PyObject *resultobj = 0;
33329 int arg1 ;
33330 int result;
33331 int val1 ;
33332 int ecode1 = 0 ;
33333 PyObject * obj0 = 0 ;
33334 char * kwnames[] = {
33335 (char *) "winid", NULL
33336 };
33337
33338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
33339 ecode1 = SWIG_AsVal_int(obj0, &val1);
33340 if (!SWIG_IsOK(ecode1)) {
33341 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
33342 }
33343 arg1 = static_cast< int >(val1);
33344 {
33345 PyThreadState* __tstate = wxPyBeginAllowThreads();
33346 result = (int)wxWindow::NextControlId(arg1);
33347 wxPyEndAllowThreads(__tstate);
33348 if (PyErr_Occurred()) SWIG_fail;
33349 }
33350 resultobj = SWIG_From_int(static_cast< int >(result));
33351 return resultobj;
33352 fail:
33353 return NULL;
33354 }
33355
33356
33357 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33358 PyObject *resultobj = 0;
33359 int arg1 ;
33360 int result;
33361 int val1 ;
33362 int ecode1 = 0 ;
33363 PyObject * obj0 = 0 ;
33364 char * kwnames[] = {
33365 (char *) "winid", NULL
33366 };
33367
33368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
33369 ecode1 = SWIG_AsVal_int(obj0, &val1);
33370 if (!SWIG_IsOK(ecode1)) {
33371 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
33372 }
33373 arg1 = static_cast< int >(val1);
33374 {
33375 PyThreadState* __tstate = wxPyBeginAllowThreads();
33376 result = (int)wxWindow::PrevControlId(arg1);
33377 wxPyEndAllowThreads(__tstate);
33378 if (PyErr_Occurred()) SWIG_fail;
33379 }
33380 resultobj = SWIG_From_int(static_cast< int >(result));
33381 return resultobj;
33382 fail:
33383 return NULL;
33384 }
33385
33386
33387 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33388 PyObject *resultobj = 0;
33389 wxWindow *arg1 = (wxWindow *) 0 ;
33390 wxLayoutDirection result;
33391 void *argp1 = 0 ;
33392 int res1 = 0 ;
33393 PyObject *swig_obj[1] ;
33394
33395 if (!args) SWIG_fail;
33396 swig_obj[0] = args;
33397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33398 if (!SWIG_IsOK(res1)) {
33399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33400 }
33401 arg1 = reinterpret_cast< wxWindow * >(argp1);
33402 {
33403 PyThreadState* __tstate = wxPyBeginAllowThreads();
33404 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
33405 wxPyEndAllowThreads(__tstate);
33406 if (PyErr_Occurred()) SWIG_fail;
33407 }
33408 resultobj = SWIG_From_int(static_cast< int >(result));
33409 return resultobj;
33410 fail:
33411 return NULL;
33412 }
33413
33414
33415 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33416 PyObject *resultobj = 0;
33417 wxWindow *arg1 = (wxWindow *) 0 ;
33418 wxLayoutDirection arg2 ;
33419 void *argp1 = 0 ;
33420 int res1 = 0 ;
33421 int val2 ;
33422 int ecode2 = 0 ;
33423 PyObject * obj0 = 0 ;
33424 PyObject * obj1 = 0 ;
33425 char * kwnames[] = {
33426 (char *) "self",(char *) "dir", NULL
33427 };
33428
33429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
33430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33431 if (!SWIG_IsOK(res1)) {
33432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
33433 }
33434 arg1 = reinterpret_cast< wxWindow * >(argp1);
33435 ecode2 = SWIG_AsVal_int(obj1, &val2);
33436 if (!SWIG_IsOK(ecode2)) {
33437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
33438 }
33439 arg2 = static_cast< wxLayoutDirection >(val2);
33440 {
33441 PyThreadState* __tstate = wxPyBeginAllowThreads();
33442 (arg1)->SetLayoutDirection(arg2);
33443 wxPyEndAllowThreads(__tstate);
33444 if (PyErr_Occurred()) SWIG_fail;
33445 }
33446 resultobj = SWIG_Py_Void();
33447 return resultobj;
33448 fail:
33449 return NULL;
33450 }
33451
33452
33453 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33454 PyObject *resultobj = 0;
33455 wxWindow *arg1 = (wxWindow *) 0 ;
33456 int arg2 ;
33457 int arg3 ;
33458 int arg4 ;
33459 int result;
33460 void *argp1 = 0 ;
33461 int res1 = 0 ;
33462 int val2 ;
33463 int ecode2 = 0 ;
33464 int val3 ;
33465 int ecode3 = 0 ;
33466 int val4 ;
33467 int ecode4 = 0 ;
33468 PyObject * obj0 = 0 ;
33469 PyObject * obj1 = 0 ;
33470 PyObject * obj2 = 0 ;
33471 PyObject * obj3 = 0 ;
33472 char * kwnames[] = {
33473 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
33474 };
33475
33476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33478 if (!SWIG_IsOK(res1)) {
33479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33480 }
33481 arg1 = reinterpret_cast< wxWindow * >(argp1);
33482 ecode2 = SWIG_AsVal_int(obj1, &val2);
33483 if (!SWIG_IsOK(ecode2)) {
33484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
33485 }
33486 arg2 = static_cast< int >(val2);
33487 ecode3 = SWIG_AsVal_int(obj2, &val3);
33488 if (!SWIG_IsOK(ecode3)) {
33489 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
33490 }
33491 arg3 = static_cast< int >(val3);
33492 ecode4 = SWIG_AsVal_int(obj3, &val4);
33493 if (!SWIG_IsOK(ecode4)) {
33494 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
33495 }
33496 arg4 = static_cast< int >(val4);
33497 {
33498 PyThreadState* __tstate = wxPyBeginAllowThreads();
33499 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
33500 wxPyEndAllowThreads(__tstate);
33501 if (PyErr_Occurred()) SWIG_fail;
33502 }
33503 resultobj = SWIG_From_int(static_cast< int >(result));
33504 return resultobj;
33505 fail:
33506 return NULL;
33507 }
33508
33509
33510 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33511 PyObject *resultobj = 0;
33512 wxWindow *arg1 = (wxWindow *) 0 ;
33513 wxSize *arg2 = 0 ;
33514 void *argp1 = 0 ;
33515 int res1 = 0 ;
33516 wxSize temp2 ;
33517 PyObject * obj0 = 0 ;
33518 PyObject * obj1 = 0 ;
33519 char * kwnames[] = {
33520 (char *) "self",(char *) "size", NULL
33521 };
33522
33523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
33524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33525 if (!SWIG_IsOK(res1)) {
33526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33527 }
33528 arg1 = reinterpret_cast< wxWindow * >(argp1);
33529 {
33530 arg2 = &temp2;
33531 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33532 }
33533 {
33534 PyThreadState* __tstate = wxPyBeginAllowThreads();
33535 (arg1)->SetSize((wxSize const &)*arg2);
33536 wxPyEndAllowThreads(__tstate);
33537 if (PyErr_Occurred()) SWIG_fail;
33538 }
33539 resultobj = SWIG_Py_Void();
33540 return resultobj;
33541 fail:
33542 return NULL;
33543 }
33544
33545
33546 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33547 PyObject *resultobj = 0;
33548 wxWindow *arg1 = (wxWindow *) 0 ;
33549 int arg2 ;
33550 int arg3 ;
33551 int arg4 ;
33552 int arg5 ;
33553 int arg6 = (int) wxSIZE_AUTO ;
33554 void *argp1 = 0 ;
33555 int res1 = 0 ;
33556 int val2 ;
33557 int ecode2 = 0 ;
33558 int val3 ;
33559 int ecode3 = 0 ;
33560 int val4 ;
33561 int ecode4 = 0 ;
33562 int val5 ;
33563 int ecode5 = 0 ;
33564 int val6 ;
33565 int ecode6 = 0 ;
33566 PyObject * obj0 = 0 ;
33567 PyObject * obj1 = 0 ;
33568 PyObject * obj2 = 0 ;
33569 PyObject * obj3 = 0 ;
33570 PyObject * obj4 = 0 ;
33571 PyObject * obj5 = 0 ;
33572 char * kwnames[] = {
33573 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
33574 };
33575
33576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
33577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33578 if (!SWIG_IsOK(res1)) {
33579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
33580 }
33581 arg1 = reinterpret_cast< wxWindow * >(argp1);
33582 ecode2 = SWIG_AsVal_int(obj1, &val2);
33583 if (!SWIG_IsOK(ecode2)) {
33584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
33585 }
33586 arg2 = static_cast< int >(val2);
33587 ecode3 = SWIG_AsVal_int(obj2, &val3);
33588 if (!SWIG_IsOK(ecode3)) {
33589 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
33590 }
33591 arg3 = static_cast< int >(val3);
33592 ecode4 = SWIG_AsVal_int(obj3, &val4);
33593 if (!SWIG_IsOK(ecode4)) {
33594 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
33595 }
33596 arg4 = static_cast< int >(val4);
33597 ecode5 = SWIG_AsVal_int(obj4, &val5);
33598 if (!SWIG_IsOK(ecode5)) {
33599 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
33600 }
33601 arg5 = static_cast< int >(val5);
33602 if (obj5) {
33603 ecode6 = SWIG_AsVal_int(obj5, &val6);
33604 if (!SWIG_IsOK(ecode6)) {
33605 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
33606 }
33607 arg6 = static_cast< int >(val6);
33608 }
33609 {
33610 PyThreadState* __tstate = wxPyBeginAllowThreads();
33611 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
33612 wxPyEndAllowThreads(__tstate);
33613 if (PyErr_Occurred()) SWIG_fail;
33614 }
33615 resultobj = SWIG_Py_Void();
33616 return resultobj;
33617 fail:
33618 return NULL;
33619 }
33620
33621
33622 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33623 PyObject *resultobj = 0;
33624 wxWindow *arg1 = (wxWindow *) 0 ;
33625 wxRect *arg2 = 0 ;
33626 int arg3 = (int) wxSIZE_AUTO ;
33627 void *argp1 = 0 ;
33628 int res1 = 0 ;
33629 wxRect temp2 ;
33630 int val3 ;
33631 int ecode3 = 0 ;
33632 PyObject * obj0 = 0 ;
33633 PyObject * obj1 = 0 ;
33634 PyObject * obj2 = 0 ;
33635 char * kwnames[] = {
33636 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
33637 };
33638
33639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33641 if (!SWIG_IsOK(res1)) {
33642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
33643 }
33644 arg1 = reinterpret_cast< wxWindow * >(argp1);
33645 {
33646 arg2 = &temp2;
33647 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
33648 }
33649 if (obj2) {
33650 ecode3 = SWIG_AsVal_int(obj2, &val3);
33651 if (!SWIG_IsOK(ecode3)) {
33652 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
33653 }
33654 arg3 = static_cast< int >(val3);
33655 }
33656 {
33657 PyThreadState* __tstate = wxPyBeginAllowThreads();
33658 (arg1)->SetSize((wxRect const &)*arg2,arg3);
33659 wxPyEndAllowThreads(__tstate);
33660 if (PyErr_Occurred()) SWIG_fail;
33661 }
33662 resultobj = SWIG_Py_Void();
33663 return resultobj;
33664 fail:
33665 return NULL;
33666 }
33667
33668
33669 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33670 PyObject *resultobj = 0;
33671 wxWindow *arg1 = (wxWindow *) 0 ;
33672 int arg2 ;
33673 int arg3 ;
33674 void *argp1 = 0 ;
33675 int res1 = 0 ;
33676 int val2 ;
33677 int ecode2 = 0 ;
33678 int val3 ;
33679 int ecode3 = 0 ;
33680 PyObject * obj0 = 0 ;
33681 PyObject * obj1 = 0 ;
33682 PyObject * obj2 = 0 ;
33683 char * kwnames[] = {
33684 (char *) "self",(char *) "width",(char *) "height", NULL
33685 };
33686
33687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33689 if (!SWIG_IsOK(res1)) {
33690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33691 }
33692 arg1 = reinterpret_cast< wxWindow * >(argp1);
33693 ecode2 = SWIG_AsVal_int(obj1, &val2);
33694 if (!SWIG_IsOK(ecode2)) {
33695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
33696 }
33697 arg2 = static_cast< int >(val2);
33698 ecode3 = SWIG_AsVal_int(obj2, &val3);
33699 if (!SWIG_IsOK(ecode3)) {
33700 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
33701 }
33702 arg3 = static_cast< int >(val3);
33703 {
33704 PyThreadState* __tstate = wxPyBeginAllowThreads();
33705 (arg1)->SetSize(arg2,arg3);
33706 wxPyEndAllowThreads(__tstate);
33707 if (PyErr_Occurred()) SWIG_fail;
33708 }
33709 resultobj = SWIG_Py_Void();
33710 return resultobj;
33711 fail:
33712 return NULL;
33713 }
33714
33715
33716 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33717 PyObject *resultobj = 0;
33718 wxWindow *arg1 = (wxWindow *) 0 ;
33719 wxPoint *arg2 = 0 ;
33720 int arg3 = (int) wxSIZE_USE_EXISTING ;
33721 void *argp1 = 0 ;
33722 int res1 = 0 ;
33723 wxPoint temp2 ;
33724 int val3 ;
33725 int ecode3 = 0 ;
33726 PyObject * obj0 = 0 ;
33727 PyObject * obj1 = 0 ;
33728 PyObject * obj2 = 0 ;
33729 char * kwnames[] = {
33730 (char *) "self",(char *) "pt",(char *) "flags", NULL
33731 };
33732
33733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33735 if (!SWIG_IsOK(res1)) {
33736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
33737 }
33738 arg1 = reinterpret_cast< wxWindow * >(argp1);
33739 {
33740 arg2 = &temp2;
33741 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33742 }
33743 if (obj2) {
33744 ecode3 = SWIG_AsVal_int(obj2, &val3);
33745 if (!SWIG_IsOK(ecode3)) {
33746 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
33747 }
33748 arg3 = static_cast< int >(val3);
33749 }
33750 {
33751 PyThreadState* __tstate = wxPyBeginAllowThreads();
33752 (arg1)->Move((wxPoint const &)*arg2,arg3);
33753 wxPyEndAllowThreads(__tstate);
33754 if (PyErr_Occurred()) SWIG_fail;
33755 }
33756 resultobj = SWIG_Py_Void();
33757 return resultobj;
33758 fail:
33759 return NULL;
33760 }
33761
33762
33763 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33764 PyObject *resultobj = 0;
33765 wxWindow *arg1 = (wxWindow *) 0 ;
33766 int arg2 ;
33767 int arg3 ;
33768 int arg4 = (int) wxSIZE_USE_EXISTING ;
33769 void *argp1 = 0 ;
33770 int res1 = 0 ;
33771 int val2 ;
33772 int ecode2 = 0 ;
33773 int val3 ;
33774 int ecode3 = 0 ;
33775 int val4 ;
33776 int ecode4 = 0 ;
33777 PyObject * obj0 = 0 ;
33778 PyObject * obj1 = 0 ;
33779 PyObject * obj2 = 0 ;
33780 PyObject * obj3 = 0 ;
33781 char * kwnames[] = {
33782 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
33783 };
33784
33785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33787 if (!SWIG_IsOK(res1)) {
33788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
33789 }
33790 arg1 = reinterpret_cast< wxWindow * >(argp1);
33791 ecode2 = SWIG_AsVal_int(obj1, &val2);
33792 if (!SWIG_IsOK(ecode2)) {
33793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
33794 }
33795 arg2 = static_cast< int >(val2);
33796 ecode3 = SWIG_AsVal_int(obj2, &val3);
33797 if (!SWIG_IsOK(ecode3)) {
33798 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
33799 }
33800 arg3 = static_cast< int >(val3);
33801 if (obj3) {
33802 ecode4 = SWIG_AsVal_int(obj3, &val4);
33803 if (!SWIG_IsOK(ecode4)) {
33804 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
33805 }
33806 arg4 = static_cast< int >(val4);
33807 }
33808 {
33809 PyThreadState* __tstate = wxPyBeginAllowThreads();
33810 (arg1)->Move(arg2,arg3,arg4);
33811 wxPyEndAllowThreads(__tstate);
33812 if (PyErr_Occurred()) SWIG_fail;
33813 }
33814 resultobj = SWIG_Py_Void();
33815 return resultobj;
33816 fail:
33817 return NULL;
33818 }
33819
33820
33821 SWIGINTERN PyObject *_wrap_Window_SetInitialSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33822 PyObject *resultobj = 0;
33823 wxWindow *arg1 = (wxWindow *) 0 ;
33824 wxSize const &arg2_defvalue = wxDefaultSize ;
33825 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
33826 void *argp1 = 0 ;
33827 int res1 = 0 ;
33828 wxSize temp2 ;
33829 PyObject * obj0 = 0 ;
33830 PyObject * obj1 = 0 ;
33831 char * kwnames[] = {
33832 (char *) "self",(char *) "size", NULL
33833 };
33834
33835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetInitialSize",kwnames,&obj0,&obj1)) SWIG_fail;
33836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33837 if (!SWIG_IsOK(res1)) {
33838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetInitialSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33839 }
33840 arg1 = reinterpret_cast< wxWindow * >(argp1);
33841 if (obj1) {
33842 {
33843 arg2 = &temp2;
33844 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33845 }
33846 }
33847 {
33848 PyThreadState* __tstate = wxPyBeginAllowThreads();
33849 (arg1)->SetInitialSize((wxSize const &)*arg2);
33850 wxPyEndAllowThreads(__tstate);
33851 if (PyErr_Occurred()) SWIG_fail;
33852 }
33853 resultobj = SWIG_Py_Void();
33854 return resultobj;
33855 fail:
33856 return NULL;
33857 }
33858
33859
33860 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33861 PyObject *resultobj = 0;
33862 wxWindow *arg1 = (wxWindow *) 0 ;
33863 void *argp1 = 0 ;
33864 int res1 = 0 ;
33865 PyObject *swig_obj[1] ;
33866
33867 if (!args) SWIG_fail;
33868 swig_obj[0] = args;
33869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33870 if (!SWIG_IsOK(res1)) {
33871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
33872 }
33873 arg1 = reinterpret_cast< wxWindow * >(argp1);
33874 {
33875 PyThreadState* __tstate = wxPyBeginAllowThreads();
33876 (arg1)->Raise();
33877 wxPyEndAllowThreads(__tstate);
33878 if (PyErr_Occurred()) SWIG_fail;
33879 }
33880 resultobj = SWIG_Py_Void();
33881 return resultobj;
33882 fail:
33883 return NULL;
33884 }
33885
33886
33887 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33888 PyObject *resultobj = 0;
33889 wxWindow *arg1 = (wxWindow *) 0 ;
33890 void *argp1 = 0 ;
33891 int res1 = 0 ;
33892 PyObject *swig_obj[1] ;
33893
33894 if (!args) SWIG_fail;
33895 swig_obj[0] = args;
33896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33897 if (!SWIG_IsOK(res1)) {
33898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
33899 }
33900 arg1 = reinterpret_cast< wxWindow * >(argp1);
33901 {
33902 PyThreadState* __tstate = wxPyBeginAllowThreads();
33903 (arg1)->Lower();
33904 wxPyEndAllowThreads(__tstate);
33905 if (PyErr_Occurred()) SWIG_fail;
33906 }
33907 resultobj = SWIG_Py_Void();
33908 return resultobj;
33909 fail:
33910 return NULL;
33911 }
33912
33913
33914 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33915 PyObject *resultobj = 0;
33916 wxWindow *arg1 = (wxWindow *) 0 ;
33917 wxSize *arg2 = 0 ;
33918 void *argp1 = 0 ;
33919 int res1 = 0 ;
33920 wxSize temp2 ;
33921 PyObject * obj0 = 0 ;
33922 PyObject * obj1 = 0 ;
33923 char * kwnames[] = {
33924 (char *) "self",(char *) "size", NULL
33925 };
33926
33927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
33928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33929 if (!SWIG_IsOK(res1)) {
33930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33931 }
33932 arg1 = reinterpret_cast< wxWindow * >(argp1);
33933 {
33934 arg2 = &temp2;
33935 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33936 }
33937 {
33938 PyThreadState* __tstate = wxPyBeginAllowThreads();
33939 (arg1)->SetClientSize((wxSize const &)*arg2);
33940 wxPyEndAllowThreads(__tstate);
33941 if (PyErr_Occurred()) SWIG_fail;
33942 }
33943 resultobj = SWIG_Py_Void();
33944 return resultobj;
33945 fail:
33946 return NULL;
33947 }
33948
33949
33950 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33951 PyObject *resultobj = 0;
33952 wxWindow *arg1 = (wxWindow *) 0 ;
33953 int arg2 ;
33954 int arg3 ;
33955 void *argp1 = 0 ;
33956 int res1 = 0 ;
33957 int val2 ;
33958 int ecode2 = 0 ;
33959 int val3 ;
33960 int ecode3 = 0 ;
33961 PyObject * obj0 = 0 ;
33962 PyObject * obj1 = 0 ;
33963 PyObject * obj2 = 0 ;
33964 char * kwnames[] = {
33965 (char *) "self",(char *) "width",(char *) "height", NULL
33966 };
33967
33968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33970 if (!SWIG_IsOK(res1)) {
33971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33972 }
33973 arg1 = reinterpret_cast< wxWindow * >(argp1);
33974 ecode2 = SWIG_AsVal_int(obj1, &val2);
33975 if (!SWIG_IsOK(ecode2)) {
33976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
33977 }
33978 arg2 = static_cast< int >(val2);
33979 ecode3 = SWIG_AsVal_int(obj2, &val3);
33980 if (!SWIG_IsOK(ecode3)) {
33981 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
33982 }
33983 arg3 = static_cast< int >(val3);
33984 {
33985 PyThreadState* __tstate = wxPyBeginAllowThreads();
33986 (arg1)->SetClientSize(arg2,arg3);
33987 wxPyEndAllowThreads(__tstate);
33988 if (PyErr_Occurred()) SWIG_fail;
33989 }
33990 resultobj = SWIG_Py_Void();
33991 return resultobj;
33992 fail:
33993 return NULL;
33994 }
33995
33996
33997 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33998 PyObject *resultobj = 0;
33999 wxWindow *arg1 = (wxWindow *) 0 ;
34000 wxRect *arg2 = 0 ;
34001 void *argp1 = 0 ;
34002 int res1 = 0 ;
34003 wxRect temp2 ;
34004 PyObject * obj0 = 0 ;
34005 PyObject * obj1 = 0 ;
34006 char * kwnames[] = {
34007 (char *) "self",(char *) "rect", NULL
34008 };
34009
34010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
34011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34012 if (!SWIG_IsOK(res1)) {
34013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34014 }
34015 arg1 = reinterpret_cast< wxWindow * >(argp1);
34016 {
34017 arg2 = &temp2;
34018 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34019 }
34020 {
34021 PyThreadState* __tstate = wxPyBeginAllowThreads();
34022 (arg1)->SetClientSize((wxRect const &)*arg2);
34023 wxPyEndAllowThreads(__tstate);
34024 if (PyErr_Occurred()) SWIG_fail;
34025 }
34026 resultobj = SWIG_Py_Void();
34027 return resultobj;
34028 fail:
34029 return NULL;
34030 }
34031
34032
34033 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34034 PyObject *resultobj = 0;
34035 wxWindow *arg1 = (wxWindow *) 0 ;
34036 wxPoint result;
34037 void *argp1 = 0 ;
34038 int res1 = 0 ;
34039 PyObject *swig_obj[1] ;
34040
34041 if (!args) SWIG_fail;
34042 swig_obj[0] = args;
34043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34044 if (!SWIG_IsOK(res1)) {
34045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34046 }
34047 arg1 = reinterpret_cast< wxWindow * >(argp1);
34048 {
34049 PyThreadState* __tstate = wxPyBeginAllowThreads();
34050 result = ((wxWindow const *)arg1)->GetPosition();
34051 wxPyEndAllowThreads(__tstate);
34052 if (PyErr_Occurred()) SWIG_fail;
34053 }
34054 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34055 return resultobj;
34056 fail:
34057 return NULL;
34058 }
34059
34060
34061 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34062 PyObject *resultobj = 0;
34063 wxWindow *arg1 = (wxWindow *) 0 ;
34064 int *arg2 = (int *) 0 ;
34065 int *arg3 = (int *) 0 ;
34066 void *argp1 = 0 ;
34067 int res1 = 0 ;
34068 int temp2 ;
34069 int res2 = SWIG_TMPOBJ ;
34070 int temp3 ;
34071 int res3 = SWIG_TMPOBJ ;
34072 PyObject *swig_obj[1] ;
34073
34074 arg2 = &temp2;
34075 arg3 = &temp3;
34076 if (!args) SWIG_fail;
34077 swig_obj[0] = args;
34078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34079 if (!SWIG_IsOK(res1)) {
34080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34081 }
34082 arg1 = reinterpret_cast< wxWindow * >(argp1);
34083 {
34084 PyThreadState* __tstate = wxPyBeginAllowThreads();
34085 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
34086 wxPyEndAllowThreads(__tstate);
34087 if (PyErr_Occurred()) SWIG_fail;
34088 }
34089 resultobj = SWIG_Py_Void();
34090 if (SWIG_IsTmpObj(res2)) {
34091 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34092 } else {
34093 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34094 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34095 }
34096 if (SWIG_IsTmpObj(res3)) {
34097 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34098 } else {
34099 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34100 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34101 }
34102 return resultobj;
34103 fail:
34104 return NULL;
34105 }
34106
34107
34108 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34109 PyObject *resultobj = 0;
34110 wxWindow *arg1 = (wxWindow *) 0 ;
34111 wxPoint result;
34112 void *argp1 = 0 ;
34113 int res1 = 0 ;
34114 PyObject *swig_obj[1] ;
34115
34116 if (!args) SWIG_fail;
34117 swig_obj[0] = args;
34118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34119 if (!SWIG_IsOK(res1)) {
34120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34121 }
34122 arg1 = reinterpret_cast< wxWindow * >(argp1);
34123 {
34124 PyThreadState* __tstate = wxPyBeginAllowThreads();
34125 result = ((wxWindow const *)arg1)->GetScreenPosition();
34126 wxPyEndAllowThreads(__tstate);
34127 if (PyErr_Occurred()) SWIG_fail;
34128 }
34129 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34130 return resultobj;
34131 fail:
34132 return NULL;
34133 }
34134
34135
34136 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34137 PyObject *resultobj = 0;
34138 wxWindow *arg1 = (wxWindow *) 0 ;
34139 int *arg2 = (int *) 0 ;
34140 int *arg3 = (int *) 0 ;
34141 void *argp1 = 0 ;
34142 int res1 = 0 ;
34143 int temp2 ;
34144 int res2 = SWIG_TMPOBJ ;
34145 int temp3 ;
34146 int res3 = SWIG_TMPOBJ ;
34147 PyObject *swig_obj[1] ;
34148
34149 arg2 = &temp2;
34150 arg3 = &temp3;
34151 if (!args) SWIG_fail;
34152 swig_obj[0] = args;
34153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34154 if (!SWIG_IsOK(res1)) {
34155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34156 }
34157 arg1 = reinterpret_cast< wxWindow * >(argp1);
34158 {
34159 PyThreadState* __tstate = wxPyBeginAllowThreads();
34160 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
34161 wxPyEndAllowThreads(__tstate);
34162 if (PyErr_Occurred()) SWIG_fail;
34163 }
34164 resultobj = SWIG_Py_Void();
34165 if (SWIG_IsTmpObj(res2)) {
34166 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34167 } else {
34168 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34169 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34170 }
34171 if (SWIG_IsTmpObj(res3)) {
34172 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34173 } else {
34174 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34175 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34176 }
34177 return resultobj;
34178 fail:
34179 return NULL;
34180 }
34181
34182
34183 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34184 PyObject *resultobj = 0;
34185 wxWindow *arg1 = (wxWindow *) 0 ;
34186 wxRect result;
34187 void *argp1 = 0 ;
34188 int res1 = 0 ;
34189 PyObject *swig_obj[1] ;
34190
34191 if (!args) SWIG_fail;
34192 swig_obj[0] = args;
34193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34194 if (!SWIG_IsOK(res1)) {
34195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34196 }
34197 arg1 = reinterpret_cast< wxWindow * >(argp1);
34198 {
34199 PyThreadState* __tstate = wxPyBeginAllowThreads();
34200 result = ((wxWindow const *)arg1)->GetScreenRect();
34201 wxPyEndAllowThreads(__tstate);
34202 if (PyErr_Occurred()) SWIG_fail;
34203 }
34204 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34205 return resultobj;
34206 fail:
34207 return NULL;
34208 }
34209
34210
34211 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34212 PyObject *resultobj = 0;
34213 wxWindow *arg1 = (wxWindow *) 0 ;
34214 wxSize result;
34215 void *argp1 = 0 ;
34216 int res1 = 0 ;
34217 PyObject *swig_obj[1] ;
34218
34219 if (!args) SWIG_fail;
34220 swig_obj[0] = args;
34221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34222 if (!SWIG_IsOK(res1)) {
34223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34224 }
34225 arg1 = reinterpret_cast< wxWindow * >(argp1);
34226 {
34227 PyThreadState* __tstate = wxPyBeginAllowThreads();
34228 result = ((wxWindow const *)arg1)->GetSize();
34229 wxPyEndAllowThreads(__tstate);
34230 if (PyErr_Occurred()) SWIG_fail;
34231 }
34232 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34233 return resultobj;
34234 fail:
34235 return NULL;
34236 }
34237
34238
34239 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34240 PyObject *resultobj = 0;
34241 wxWindow *arg1 = (wxWindow *) 0 ;
34242 int *arg2 = (int *) 0 ;
34243 int *arg3 = (int *) 0 ;
34244 void *argp1 = 0 ;
34245 int res1 = 0 ;
34246 int temp2 ;
34247 int res2 = SWIG_TMPOBJ ;
34248 int temp3 ;
34249 int res3 = SWIG_TMPOBJ ;
34250 PyObject *swig_obj[1] ;
34251
34252 arg2 = &temp2;
34253 arg3 = &temp3;
34254 if (!args) SWIG_fail;
34255 swig_obj[0] = args;
34256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34257 if (!SWIG_IsOK(res1)) {
34258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34259 }
34260 arg1 = reinterpret_cast< wxWindow * >(argp1);
34261 {
34262 PyThreadState* __tstate = wxPyBeginAllowThreads();
34263 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
34264 wxPyEndAllowThreads(__tstate);
34265 if (PyErr_Occurred()) SWIG_fail;
34266 }
34267 resultobj = SWIG_Py_Void();
34268 if (SWIG_IsTmpObj(res2)) {
34269 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34270 } else {
34271 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34272 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34273 }
34274 if (SWIG_IsTmpObj(res3)) {
34275 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34276 } else {
34277 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34278 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34279 }
34280 return resultobj;
34281 fail:
34282 return NULL;
34283 }
34284
34285
34286 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34287 PyObject *resultobj = 0;
34288 wxWindow *arg1 = (wxWindow *) 0 ;
34289 wxRect result;
34290 void *argp1 = 0 ;
34291 int res1 = 0 ;
34292 PyObject *swig_obj[1] ;
34293
34294 if (!args) SWIG_fail;
34295 swig_obj[0] = args;
34296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34297 if (!SWIG_IsOK(res1)) {
34298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34299 }
34300 arg1 = reinterpret_cast< wxWindow * >(argp1);
34301 {
34302 PyThreadState* __tstate = wxPyBeginAllowThreads();
34303 result = ((wxWindow const *)arg1)->GetRect();
34304 wxPyEndAllowThreads(__tstate);
34305 if (PyErr_Occurred()) SWIG_fail;
34306 }
34307 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34308 return resultobj;
34309 fail:
34310 return NULL;
34311 }
34312
34313
34314 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34315 PyObject *resultobj = 0;
34316 wxWindow *arg1 = (wxWindow *) 0 ;
34317 wxSize result;
34318 void *argp1 = 0 ;
34319 int res1 = 0 ;
34320 PyObject *swig_obj[1] ;
34321
34322 if (!args) SWIG_fail;
34323 swig_obj[0] = args;
34324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34325 if (!SWIG_IsOK(res1)) {
34326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34327 }
34328 arg1 = reinterpret_cast< wxWindow * >(argp1);
34329 {
34330 PyThreadState* __tstate = wxPyBeginAllowThreads();
34331 result = ((wxWindow const *)arg1)->GetClientSize();
34332 wxPyEndAllowThreads(__tstate);
34333 if (PyErr_Occurred()) SWIG_fail;
34334 }
34335 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34336 return resultobj;
34337 fail:
34338 return NULL;
34339 }
34340
34341
34342 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34343 PyObject *resultobj = 0;
34344 wxWindow *arg1 = (wxWindow *) 0 ;
34345 int *arg2 = (int *) 0 ;
34346 int *arg3 = (int *) 0 ;
34347 void *argp1 = 0 ;
34348 int res1 = 0 ;
34349 int temp2 ;
34350 int res2 = SWIG_TMPOBJ ;
34351 int temp3 ;
34352 int res3 = SWIG_TMPOBJ ;
34353 PyObject *swig_obj[1] ;
34354
34355 arg2 = &temp2;
34356 arg3 = &temp3;
34357 if (!args) SWIG_fail;
34358 swig_obj[0] = args;
34359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34360 if (!SWIG_IsOK(res1)) {
34361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34362 }
34363 arg1 = reinterpret_cast< wxWindow * >(argp1);
34364 {
34365 PyThreadState* __tstate = wxPyBeginAllowThreads();
34366 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
34367 wxPyEndAllowThreads(__tstate);
34368 if (PyErr_Occurred()) SWIG_fail;
34369 }
34370 resultobj = SWIG_Py_Void();
34371 if (SWIG_IsTmpObj(res2)) {
34372 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34373 } else {
34374 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34375 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34376 }
34377 if (SWIG_IsTmpObj(res3)) {
34378 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34379 } else {
34380 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34381 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34382 }
34383 return resultobj;
34384 fail:
34385 return NULL;
34386 }
34387
34388
34389 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34390 PyObject *resultobj = 0;
34391 wxWindow *arg1 = (wxWindow *) 0 ;
34392 wxPoint result;
34393 void *argp1 = 0 ;
34394 int res1 = 0 ;
34395 PyObject *swig_obj[1] ;
34396
34397 if (!args) SWIG_fail;
34398 swig_obj[0] = args;
34399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34400 if (!SWIG_IsOK(res1)) {
34401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
34402 }
34403 arg1 = reinterpret_cast< wxWindow * >(argp1);
34404 {
34405 PyThreadState* __tstate = wxPyBeginAllowThreads();
34406 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
34407 wxPyEndAllowThreads(__tstate);
34408 if (PyErr_Occurred()) SWIG_fail;
34409 }
34410 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34411 return resultobj;
34412 fail:
34413 return NULL;
34414 }
34415
34416
34417 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34418 PyObject *resultobj = 0;
34419 wxWindow *arg1 = (wxWindow *) 0 ;
34420 wxRect result;
34421 void *argp1 = 0 ;
34422 int res1 = 0 ;
34423 PyObject *swig_obj[1] ;
34424
34425 if (!args) SWIG_fail;
34426 swig_obj[0] = args;
34427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34428 if (!SWIG_IsOK(res1)) {
34429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34430 }
34431 arg1 = reinterpret_cast< wxWindow * >(argp1);
34432 {
34433 PyThreadState* __tstate = wxPyBeginAllowThreads();
34434 result = ((wxWindow const *)arg1)->GetClientRect();
34435 wxPyEndAllowThreads(__tstate);
34436 if (PyErr_Occurred()) SWIG_fail;
34437 }
34438 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34439 return resultobj;
34440 fail:
34441 return NULL;
34442 }
34443
34444
34445 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34446 PyObject *resultobj = 0;
34447 wxWindow *arg1 = (wxWindow *) 0 ;
34448 wxSize result;
34449 void *argp1 = 0 ;
34450 int res1 = 0 ;
34451 PyObject *swig_obj[1] ;
34452
34453 if (!args) SWIG_fail;
34454 swig_obj[0] = args;
34455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34456 if (!SWIG_IsOK(res1)) {
34457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34458 }
34459 arg1 = reinterpret_cast< wxWindow * >(argp1);
34460 {
34461 PyThreadState* __tstate = wxPyBeginAllowThreads();
34462 result = ((wxWindow const *)arg1)->GetBestSize();
34463 wxPyEndAllowThreads(__tstate);
34464 if (PyErr_Occurred()) SWIG_fail;
34465 }
34466 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34467 return resultobj;
34468 fail:
34469 return NULL;
34470 }
34471
34472
34473 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34474 PyObject *resultobj = 0;
34475 wxWindow *arg1 = (wxWindow *) 0 ;
34476 int *arg2 = (int *) 0 ;
34477 int *arg3 = (int *) 0 ;
34478 void *argp1 = 0 ;
34479 int res1 = 0 ;
34480 int temp2 ;
34481 int res2 = SWIG_TMPOBJ ;
34482 int temp3 ;
34483 int res3 = SWIG_TMPOBJ ;
34484 PyObject *swig_obj[1] ;
34485
34486 arg2 = &temp2;
34487 arg3 = &temp3;
34488 if (!args) SWIG_fail;
34489 swig_obj[0] = args;
34490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34491 if (!SWIG_IsOK(res1)) {
34492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34493 }
34494 arg1 = reinterpret_cast< wxWindow * >(argp1);
34495 {
34496 PyThreadState* __tstate = wxPyBeginAllowThreads();
34497 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
34498 wxPyEndAllowThreads(__tstate);
34499 if (PyErr_Occurred()) SWIG_fail;
34500 }
34501 resultobj = SWIG_Py_Void();
34502 if (SWIG_IsTmpObj(res2)) {
34503 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34504 } else {
34505 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34506 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34507 }
34508 if (SWIG_IsTmpObj(res3)) {
34509 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34510 } else {
34511 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34512 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34513 }
34514 return resultobj;
34515 fail:
34516 return NULL;
34517 }
34518
34519
34520 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34521 PyObject *resultobj = 0;
34522 wxWindow *arg1 = (wxWindow *) 0 ;
34523 void *argp1 = 0 ;
34524 int res1 = 0 ;
34525 PyObject *swig_obj[1] ;
34526
34527 if (!args) SWIG_fail;
34528 swig_obj[0] = args;
34529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34530 if (!SWIG_IsOK(res1)) {
34531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34532 }
34533 arg1 = reinterpret_cast< wxWindow * >(argp1);
34534 {
34535 PyThreadState* __tstate = wxPyBeginAllowThreads();
34536 (arg1)->InvalidateBestSize();
34537 wxPyEndAllowThreads(__tstate);
34538 if (PyErr_Occurred()) SWIG_fail;
34539 }
34540 resultobj = SWIG_Py_Void();
34541 return resultobj;
34542 fail:
34543 return NULL;
34544 }
34545
34546
34547 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34548 PyObject *resultobj = 0;
34549 wxWindow *arg1 = (wxWindow *) 0 ;
34550 wxSize *arg2 = 0 ;
34551 void *argp1 = 0 ;
34552 int res1 = 0 ;
34553 wxSize temp2 ;
34554 PyObject * obj0 = 0 ;
34555 PyObject * obj1 = 0 ;
34556 char * kwnames[] = {
34557 (char *) "self",(char *) "size", NULL
34558 };
34559
34560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
34561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34562 if (!SWIG_IsOK(res1)) {
34563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34564 }
34565 arg1 = reinterpret_cast< wxWindow * >(argp1);
34566 {
34567 arg2 = &temp2;
34568 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34569 }
34570 {
34571 PyThreadState* __tstate = wxPyBeginAllowThreads();
34572 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
34573 wxPyEndAllowThreads(__tstate);
34574 if (PyErr_Occurred()) SWIG_fail;
34575 }
34576 resultobj = SWIG_Py_Void();
34577 return resultobj;
34578 fail:
34579 return NULL;
34580 }
34581
34582
34583 SWIGINTERN PyObject *_wrap_Window_GetEffectiveMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34584 PyObject *resultobj = 0;
34585 wxWindow *arg1 = (wxWindow *) 0 ;
34586 wxSize result;
34587 void *argp1 = 0 ;
34588 int res1 = 0 ;
34589 PyObject *swig_obj[1] ;
34590
34591 if (!args) SWIG_fail;
34592 swig_obj[0] = args;
34593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34594 if (!SWIG_IsOK(res1)) {
34595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEffectiveMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34596 }
34597 arg1 = reinterpret_cast< wxWindow * >(argp1);
34598 {
34599 PyThreadState* __tstate = wxPyBeginAllowThreads();
34600 result = ((wxWindow const *)arg1)->GetEffectiveMinSize();
34601 wxPyEndAllowThreads(__tstate);
34602 if (PyErr_Occurred()) SWIG_fail;
34603 }
34604 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34605 return resultobj;
34606 fail:
34607 return NULL;
34608 }
34609
34610
34611 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34612 PyObject *resultobj = 0;
34613 wxWindow *arg1 = (wxWindow *) 0 ;
34614 int arg2 = (int) wxBOTH ;
34615 void *argp1 = 0 ;
34616 int res1 = 0 ;
34617 int val2 ;
34618 int ecode2 = 0 ;
34619 PyObject * obj0 = 0 ;
34620 PyObject * obj1 = 0 ;
34621 char * kwnames[] = {
34622 (char *) "self",(char *) "direction", NULL
34623 };
34624
34625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
34626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34627 if (!SWIG_IsOK(res1)) {
34628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
34629 }
34630 arg1 = reinterpret_cast< wxWindow * >(argp1);
34631 if (obj1) {
34632 ecode2 = SWIG_AsVal_int(obj1, &val2);
34633 if (!SWIG_IsOK(ecode2)) {
34634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
34635 }
34636 arg2 = static_cast< int >(val2);
34637 }
34638 {
34639 PyThreadState* __tstate = wxPyBeginAllowThreads();
34640 (arg1)->Center(arg2);
34641 wxPyEndAllowThreads(__tstate);
34642 if (PyErr_Occurred()) SWIG_fail;
34643 }
34644 resultobj = SWIG_Py_Void();
34645 return resultobj;
34646 fail:
34647 return NULL;
34648 }
34649
34650
34651 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34652 PyObject *resultobj = 0;
34653 wxWindow *arg1 = (wxWindow *) 0 ;
34654 int arg2 = (int) wxBOTH ;
34655 void *argp1 = 0 ;
34656 int res1 = 0 ;
34657 int val2 ;
34658 int ecode2 = 0 ;
34659 PyObject * obj0 = 0 ;
34660 PyObject * obj1 = 0 ;
34661 char * kwnames[] = {
34662 (char *) "self",(char *) "dir", NULL
34663 };
34664
34665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
34666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34667 if (!SWIG_IsOK(res1)) {
34668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
34669 }
34670 arg1 = reinterpret_cast< wxWindow * >(argp1);
34671 if (obj1) {
34672 ecode2 = SWIG_AsVal_int(obj1, &val2);
34673 if (!SWIG_IsOK(ecode2)) {
34674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
34675 }
34676 arg2 = static_cast< int >(val2);
34677 }
34678 {
34679 PyThreadState* __tstate = wxPyBeginAllowThreads();
34680 (arg1)->CenterOnParent(arg2);
34681 wxPyEndAllowThreads(__tstate);
34682 if (PyErr_Occurred()) SWIG_fail;
34683 }
34684 resultobj = SWIG_Py_Void();
34685 return resultobj;
34686 fail:
34687 return NULL;
34688 }
34689
34690
34691 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34692 PyObject *resultobj = 0;
34693 wxWindow *arg1 = (wxWindow *) 0 ;
34694 void *argp1 = 0 ;
34695 int res1 = 0 ;
34696 PyObject *swig_obj[1] ;
34697
34698 if (!args) SWIG_fail;
34699 swig_obj[0] = args;
34700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34701 if (!SWIG_IsOK(res1)) {
34702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
34703 }
34704 arg1 = reinterpret_cast< wxWindow * >(argp1);
34705 {
34706 PyThreadState* __tstate = wxPyBeginAllowThreads();
34707 (arg1)->Fit();
34708 wxPyEndAllowThreads(__tstate);
34709 if (PyErr_Occurred()) SWIG_fail;
34710 }
34711 resultobj = SWIG_Py_Void();
34712 return resultobj;
34713 fail:
34714 return NULL;
34715 }
34716
34717
34718 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34719 PyObject *resultobj = 0;
34720 wxWindow *arg1 = (wxWindow *) 0 ;
34721 void *argp1 = 0 ;
34722 int res1 = 0 ;
34723 PyObject *swig_obj[1] ;
34724
34725 if (!args) SWIG_fail;
34726 swig_obj[0] = args;
34727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34728 if (!SWIG_IsOK(res1)) {
34729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
34730 }
34731 arg1 = reinterpret_cast< wxWindow * >(argp1);
34732 {
34733 PyThreadState* __tstate = wxPyBeginAllowThreads();
34734 (arg1)->FitInside();
34735 wxPyEndAllowThreads(__tstate);
34736 if (PyErr_Occurred()) SWIG_fail;
34737 }
34738 resultobj = SWIG_Py_Void();
34739 return resultobj;
34740 fail:
34741 return NULL;
34742 }
34743
34744
34745 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34746 PyObject *resultobj = 0;
34747 wxWindow *arg1 = (wxWindow *) 0 ;
34748 int arg2 ;
34749 int arg3 ;
34750 int arg4 = (int) -1 ;
34751 int arg5 = (int) -1 ;
34752 int arg6 = (int) -1 ;
34753 int arg7 = (int) -1 ;
34754 void *argp1 = 0 ;
34755 int res1 = 0 ;
34756 int val2 ;
34757 int ecode2 = 0 ;
34758 int val3 ;
34759 int ecode3 = 0 ;
34760 int val4 ;
34761 int ecode4 = 0 ;
34762 int val5 ;
34763 int ecode5 = 0 ;
34764 int val6 ;
34765 int ecode6 = 0 ;
34766 int val7 ;
34767 int ecode7 = 0 ;
34768 PyObject * obj0 = 0 ;
34769 PyObject * obj1 = 0 ;
34770 PyObject * obj2 = 0 ;
34771 PyObject * obj3 = 0 ;
34772 PyObject * obj4 = 0 ;
34773 PyObject * obj5 = 0 ;
34774 PyObject * obj6 = 0 ;
34775 char * kwnames[] = {
34776 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
34777 };
34778
34779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
34780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34781 if (!SWIG_IsOK(res1)) {
34782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34783 }
34784 arg1 = reinterpret_cast< wxWindow * >(argp1);
34785 ecode2 = SWIG_AsVal_int(obj1, &val2);
34786 if (!SWIG_IsOK(ecode2)) {
34787 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
34788 }
34789 arg2 = static_cast< int >(val2);
34790 ecode3 = SWIG_AsVal_int(obj2, &val3);
34791 if (!SWIG_IsOK(ecode3)) {
34792 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
34793 }
34794 arg3 = static_cast< int >(val3);
34795 if (obj3) {
34796 ecode4 = SWIG_AsVal_int(obj3, &val4);
34797 if (!SWIG_IsOK(ecode4)) {
34798 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
34799 }
34800 arg4 = static_cast< int >(val4);
34801 }
34802 if (obj4) {
34803 ecode5 = SWIG_AsVal_int(obj4, &val5);
34804 if (!SWIG_IsOK(ecode5)) {
34805 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
34806 }
34807 arg5 = static_cast< int >(val5);
34808 }
34809 if (obj5) {
34810 ecode6 = SWIG_AsVal_int(obj5, &val6);
34811 if (!SWIG_IsOK(ecode6)) {
34812 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
34813 }
34814 arg6 = static_cast< int >(val6);
34815 }
34816 if (obj6) {
34817 ecode7 = SWIG_AsVal_int(obj6, &val7);
34818 if (!SWIG_IsOK(ecode7)) {
34819 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
34820 }
34821 arg7 = static_cast< int >(val7);
34822 }
34823 {
34824 PyThreadState* __tstate = wxPyBeginAllowThreads();
34825 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
34826 wxPyEndAllowThreads(__tstate);
34827 if (PyErr_Occurred()) SWIG_fail;
34828 }
34829 resultobj = SWIG_Py_Void();
34830 return resultobj;
34831 fail:
34832 return NULL;
34833 }
34834
34835
34836 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34837 PyObject *resultobj = 0;
34838 wxWindow *arg1 = (wxWindow *) 0 ;
34839 wxSize *arg2 = 0 ;
34840 wxSize const &arg3_defvalue = wxDefaultSize ;
34841 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
34842 wxSize const &arg4_defvalue = wxDefaultSize ;
34843 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
34844 void *argp1 = 0 ;
34845 int res1 = 0 ;
34846 wxSize temp2 ;
34847 wxSize temp3 ;
34848 wxSize temp4 ;
34849 PyObject * obj0 = 0 ;
34850 PyObject * obj1 = 0 ;
34851 PyObject * obj2 = 0 ;
34852 PyObject * obj3 = 0 ;
34853 char * kwnames[] = {
34854 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
34855 };
34856
34857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34859 if (!SWIG_IsOK(res1)) {
34860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
34861 }
34862 arg1 = reinterpret_cast< wxWindow * >(argp1);
34863 {
34864 arg2 = &temp2;
34865 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34866 }
34867 if (obj2) {
34868 {
34869 arg3 = &temp3;
34870 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
34871 }
34872 }
34873 if (obj3) {
34874 {
34875 arg4 = &temp4;
34876 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
34877 }
34878 }
34879 {
34880 PyThreadState* __tstate = wxPyBeginAllowThreads();
34881 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
34882 wxPyEndAllowThreads(__tstate);
34883 if (PyErr_Occurred()) SWIG_fail;
34884 }
34885 resultobj = SWIG_Py_Void();
34886 return resultobj;
34887 fail:
34888 return NULL;
34889 }
34890
34891
34892 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34893 PyObject *resultobj = 0;
34894 wxWindow *arg1 = (wxWindow *) 0 ;
34895 int arg2 ;
34896 int arg3 ;
34897 int arg4 = (int) -1 ;
34898 int arg5 = (int) -1 ;
34899 void *argp1 = 0 ;
34900 int res1 = 0 ;
34901 int val2 ;
34902 int ecode2 = 0 ;
34903 int val3 ;
34904 int ecode3 = 0 ;
34905 int val4 ;
34906 int ecode4 = 0 ;
34907 int val5 ;
34908 int ecode5 = 0 ;
34909 PyObject * obj0 = 0 ;
34910 PyObject * obj1 = 0 ;
34911 PyObject * obj2 = 0 ;
34912 PyObject * obj3 = 0 ;
34913 PyObject * obj4 = 0 ;
34914 char * kwnames[] = {
34915 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
34916 };
34917
34918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34920 if (!SWIG_IsOK(res1)) {
34921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34922 }
34923 arg1 = reinterpret_cast< wxWindow * >(argp1);
34924 ecode2 = SWIG_AsVal_int(obj1, &val2);
34925 if (!SWIG_IsOK(ecode2)) {
34926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
34927 }
34928 arg2 = static_cast< int >(val2);
34929 ecode3 = SWIG_AsVal_int(obj2, &val3);
34930 if (!SWIG_IsOK(ecode3)) {
34931 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
34932 }
34933 arg3 = static_cast< int >(val3);
34934 if (obj3) {
34935 ecode4 = SWIG_AsVal_int(obj3, &val4);
34936 if (!SWIG_IsOK(ecode4)) {
34937 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
34938 }
34939 arg4 = static_cast< int >(val4);
34940 }
34941 if (obj4) {
34942 ecode5 = SWIG_AsVal_int(obj4, &val5);
34943 if (!SWIG_IsOK(ecode5)) {
34944 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
34945 }
34946 arg5 = static_cast< int >(val5);
34947 }
34948 {
34949 PyThreadState* __tstate = wxPyBeginAllowThreads();
34950 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
34951 wxPyEndAllowThreads(__tstate);
34952 if (PyErr_Occurred()) SWIG_fail;
34953 }
34954 resultobj = SWIG_Py_Void();
34955 return resultobj;
34956 fail:
34957 return NULL;
34958 }
34959
34960
34961 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34962 PyObject *resultobj = 0;
34963 wxWindow *arg1 = (wxWindow *) 0 ;
34964 wxSize *arg2 = 0 ;
34965 wxSize const &arg3_defvalue = wxDefaultSize ;
34966 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
34967 void *argp1 = 0 ;
34968 int res1 = 0 ;
34969 wxSize temp2 ;
34970 wxSize temp3 ;
34971 PyObject * obj0 = 0 ;
34972 PyObject * obj1 = 0 ;
34973 PyObject * obj2 = 0 ;
34974 char * kwnames[] = {
34975 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
34976 };
34977
34978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34980 if (!SWIG_IsOK(res1)) {
34981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
34982 }
34983 arg1 = reinterpret_cast< wxWindow * >(argp1);
34984 {
34985 arg2 = &temp2;
34986 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34987 }
34988 if (obj2) {
34989 {
34990 arg3 = &temp3;
34991 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
34992 }
34993 }
34994 {
34995 PyThreadState* __tstate = wxPyBeginAllowThreads();
34996 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
34997 wxPyEndAllowThreads(__tstate);
34998 if (PyErr_Occurred()) SWIG_fail;
34999 }
35000 resultobj = SWIG_Py_Void();
35001 return resultobj;
35002 fail:
35003 return NULL;
35004 }
35005
35006
35007 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35008 PyObject *resultobj = 0;
35009 wxWindow *arg1 = (wxWindow *) 0 ;
35010 wxSize result;
35011 void *argp1 = 0 ;
35012 int res1 = 0 ;
35013 PyObject *swig_obj[1] ;
35014
35015 if (!args) SWIG_fail;
35016 swig_obj[0] = args;
35017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35018 if (!SWIG_IsOK(res1)) {
35019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35020 }
35021 arg1 = reinterpret_cast< wxWindow * >(argp1);
35022 {
35023 PyThreadState* __tstate = wxPyBeginAllowThreads();
35024 result = ((wxWindow const *)arg1)->GetMaxSize();
35025 wxPyEndAllowThreads(__tstate);
35026 if (PyErr_Occurred()) SWIG_fail;
35027 }
35028 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35029 return resultobj;
35030 fail:
35031 return NULL;
35032 }
35033
35034
35035 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35036 PyObject *resultobj = 0;
35037 wxWindow *arg1 = (wxWindow *) 0 ;
35038 wxSize result;
35039 void *argp1 = 0 ;
35040 int res1 = 0 ;
35041 PyObject *swig_obj[1] ;
35042
35043 if (!args) SWIG_fail;
35044 swig_obj[0] = args;
35045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35046 if (!SWIG_IsOK(res1)) {
35047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35048 }
35049 arg1 = reinterpret_cast< wxWindow * >(argp1);
35050 {
35051 PyThreadState* __tstate = wxPyBeginAllowThreads();
35052 result = ((wxWindow const *)arg1)->GetMinSize();
35053 wxPyEndAllowThreads(__tstate);
35054 if (PyErr_Occurred()) SWIG_fail;
35055 }
35056 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35057 return resultobj;
35058 fail:
35059 return NULL;
35060 }
35061
35062
35063 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35064 PyObject *resultobj = 0;
35065 wxWindow *arg1 = (wxWindow *) 0 ;
35066 wxSize *arg2 = 0 ;
35067 void *argp1 = 0 ;
35068 int res1 = 0 ;
35069 wxSize temp2 ;
35070 PyObject * obj0 = 0 ;
35071 PyObject * obj1 = 0 ;
35072 char * kwnames[] = {
35073 (char *) "self",(char *) "minSize", NULL
35074 };
35075
35076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
35077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35078 if (!SWIG_IsOK(res1)) {
35079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35080 }
35081 arg1 = reinterpret_cast< wxWindow * >(argp1);
35082 {
35083 arg2 = &temp2;
35084 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35085 }
35086 {
35087 PyThreadState* __tstate = wxPyBeginAllowThreads();
35088 (arg1)->SetMinSize((wxSize const &)*arg2);
35089 wxPyEndAllowThreads(__tstate);
35090 if (PyErr_Occurred()) SWIG_fail;
35091 }
35092 resultobj = SWIG_Py_Void();
35093 return resultobj;
35094 fail:
35095 return NULL;
35096 }
35097
35098
35099 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35100 PyObject *resultobj = 0;
35101 wxWindow *arg1 = (wxWindow *) 0 ;
35102 wxSize *arg2 = 0 ;
35103 void *argp1 = 0 ;
35104 int res1 = 0 ;
35105 wxSize temp2 ;
35106 PyObject * obj0 = 0 ;
35107 PyObject * obj1 = 0 ;
35108 char * kwnames[] = {
35109 (char *) "self",(char *) "maxSize", NULL
35110 };
35111
35112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
35113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35114 if (!SWIG_IsOK(res1)) {
35115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35116 }
35117 arg1 = reinterpret_cast< wxWindow * >(argp1);
35118 {
35119 arg2 = &temp2;
35120 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35121 }
35122 {
35123 PyThreadState* __tstate = wxPyBeginAllowThreads();
35124 (arg1)->SetMaxSize((wxSize const &)*arg2);
35125 wxPyEndAllowThreads(__tstate);
35126 if (PyErr_Occurred()) SWIG_fail;
35127 }
35128 resultobj = SWIG_Py_Void();
35129 return resultobj;
35130 fail:
35131 return NULL;
35132 }
35133
35134
35135 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35136 PyObject *resultobj = 0;
35137 wxWindow *arg1 = (wxWindow *) 0 ;
35138 int result;
35139 void *argp1 = 0 ;
35140 int res1 = 0 ;
35141 PyObject *swig_obj[1] ;
35142
35143 if (!args) SWIG_fail;
35144 swig_obj[0] = args;
35145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35146 if (!SWIG_IsOK(res1)) {
35147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35148 }
35149 arg1 = reinterpret_cast< wxWindow * >(argp1);
35150 {
35151 PyThreadState* __tstate = wxPyBeginAllowThreads();
35152 result = (int)((wxWindow const *)arg1)->GetMinWidth();
35153 wxPyEndAllowThreads(__tstate);
35154 if (PyErr_Occurred()) SWIG_fail;
35155 }
35156 resultobj = SWIG_From_int(static_cast< int >(result));
35157 return resultobj;
35158 fail:
35159 return NULL;
35160 }
35161
35162
35163 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35164 PyObject *resultobj = 0;
35165 wxWindow *arg1 = (wxWindow *) 0 ;
35166 int result;
35167 void *argp1 = 0 ;
35168 int res1 = 0 ;
35169 PyObject *swig_obj[1] ;
35170
35171 if (!args) SWIG_fail;
35172 swig_obj[0] = args;
35173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35174 if (!SWIG_IsOK(res1)) {
35175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35176 }
35177 arg1 = reinterpret_cast< wxWindow * >(argp1);
35178 {
35179 PyThreadState* __tstate = wxPyBeginAllowThreads();
35180 result = (int)((wxWindow const *)arg1)->GetMinHeight();
35181 wxPyEndAllowThreads(__tstate);
35182 if (PyErr_Occurred()) SWIG_fail;
35183 }
35184 resultobj = SWIG_From_int(static_cast< int >(result));
35185 return resultobj;
35186 fail:
35187 return NULL;
35188 }
35189
35190
35191 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35192 PyObject *resultobj = 0;
35193 wxWindow *arg1 = (wxWindow *) 0 ;
35194 int result;
35195 void *argp1 = 0 ;
35196 int res1 = 0 ;
35197 PyObject *swig_obj[1] ;
35198
35199 if (!args) SWIG_fail;
35200 swig_obj[0] = args;
35201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35202 if (!SWIG_IsOK(res1)) {
35203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35204 }
35205 arg1 = reinterpret_cast< wxWindow * >(argp1);
35206 {
35207 PyThreadState* __tstate = wxPyBeginAllowThreads();
35208 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
35209 wxPyEndAllowThreads(__tstate);
35210 if (PyErr_Occurred()) SWIG_fail;
35211 }
35212 resultobj = SWIG_From_int(static_cast< int >(result));
35213 return resultobj;
35214 fail:
35215 return NULL;
35216 }
35217
35218
35219 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35220 PyObject *resultobj = 0;
35221 wxWindow *arg1 = (wxWindow *) 0 ;
35222 int result;
35223 void *argp1 = 0 ;
35224 int res1 = 0 ;
35225 PyObject *swig_obj[1] ;
35226
35227 if (!args) SWIG_fail;
35228 swig_obj[0] = args;
35229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35230 if (!SWIG_IsOK(res1)) {
35231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35232 }
35233 arg1 = reinterpret_cast< wxWindow * >(argp1);
35234 {
35235 PyThreadState* __tstate = wxPyBeginAllowThreads();
35236 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
35237 wxPyEndAllowThreads(__tstate);
35238 if (PyErr_Occurred()) SWIG_fail;
35239 }
35240 resultobj = SWIG_From_int(static_cast< int >(result));
35241 return resultobj;
35242 fail:
35243 return NULL;
35244 }
35245
35246
35247 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35248 PyObject *resultobj = 0;
35249 wxWindow *arg1 = (wxWindow *) 0 ;
35250 wxSize *arg2 = 0 ;
35251 void *argp1 = 0 ;
35252 int res1 = 0 ;
35253 wxSize temp2 ;
35254 PyObject * obj0 = 0 ;
35255 PyObject * obj1 = 0 ;
35256 char * kwnames[] = {
35257 (char *) "self",(char *) "size", NULL
35258 };
35259
35260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
35261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35262 if (!SWIG_IsOK(res1)) {
35263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35264 }
35265 arg1 = reinterpret_cast< wxWindow * >(argp1);
35266 {
35267 arg2 = &temp2;
35268 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35269 }
35270 {
35271 PyThreadState* __tstate = wxPyBeginAllowThreads();
35272 (arg1)->SetVirtualSize((wxSize const &)*arg2);
35273 wxPyEndAllowThreads(__tstate);
35274 if (PyErr_Occurred()) SWIG_fail;
35275 }
35276 resultobj = SWIG_Py_Void();
35277 return resultobj;
35278 fail:
35279 return NULL;
35280 }
35281
35282
35283 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35284 PyObject *resultobj = 0;
35285 wxWindow *arg1 = (wxWindow *) 0 ;
35286 int arg2 ;
35287 int arg3 ;
35288 void *argp1 = 0 ;
35289 int res1 = 0 ;
35290 int val2 ;
35291 int ecode2 = 0 ;
35292 int val3 ;
35293 int ecode3 = 0 ;
35294 PyObject * obj0 = 0 ;
35295 PyObject * obj1 = 0 ;
35296 PyObject * obj2 = 0 ;
35297 char * kwnames[] = {
35298 (char *) "self",(char *) "w",(char *) "h", NULL
35299 };
35300
35301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35303 if (!SWIG_IsOK(res1)) {
35304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
35305 }
35306 arg1 = reinterpret_cast< wxWindow * >(argp1);
35307 ecode2 = SWIG_AsVal_int(obj1, &val2);
35308 if (!SWIG_IsOK(ecode2)) {
35309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
35310 }
35311 arg2 = static_cast< int >(val2);
35312 ecode3 = SWIG_AsVal_int(obj2, &val3);
35313 if (!SWIG_IsOK(ecode3)) {
35314 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
35315 }
35316 arg3 = static_cast< int >(val3);
35317 {
35318 PyThreadState* __tstate = wxPyBeginAllowThreads();
35319 (arg1)->SetVirtualSize(arg2,arg3);
35320 wxPyEndAllowThreads(__tstate);
35321 if (PyErr_Occurred()) SWIG_fail;
35322 }
35323 resultobj = SWIG_Py_Void();
35324 return resultobj;
35325 fail:
35326 return NULL;
35327 }
35328
35329
35330 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35331 PyObject *resultobj = 0;
35332 wxWindow *arg1 = (wxWindow *) 0 ;
35333 wxSize result;
35334 void *argp1 = 0 ;
35335 int res1 = 0 ;
35336 PyObject *swig_obj[1] ;
35337
35338 if (!args) SWIG_fail;
35339 swig_obj[0] = args;
35340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35341 if (!SWIG_IsOK(res1)) {
35342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35343 }
35344 arg1 = reinterpret_cast< wxWindow * >(argp1);
35345 {
35346 PyThreadState* __tstate = wxPyBeginAllowThreads();
35347 result = ((wxWindow const *)arg1)->GetVirtualSize();
35348 wxPyEndAllowThreads(__tstate);
35349 if (PyErr_Occurred()) SWIG_fail;
35350 }
35351 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35352 return resultobj;
35353 fail:
35354 return NULL;
35355 }
35356
35357
35358 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35359 PyObject *resultobj = 0;
35360 wxWindow *arg1 = (wxWindow *) 0 ;
35361 int *arg2 = (int *) 0 ;
35362 int *arg3 = (int *) 0 ;
35363 void *argp1 = 0 ;
35364 int res1 = 0 ;
35365 int temp2 ;
35366 int res2 = SWIG_TMPOBJ ;
35367 int temp3 ;
35368 int res3 = SWIG_TMPOBJ ;
35369 PyObject *swig_obj[1] ;
35370
35371 arg2 = &temp2;
35372 arg3 = &temp3;
35373 if (!args) SWIG_fail;
35374 swig_obj[0] = args;
35375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35376 if (!SWIG_IsOK(res1)) {
35377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
35378 }
35379 arg1 = reinterpret_cast< wxWindow * >(argp1);
35380 {
35381 PyThreadState* __tstate = wxPyBeginAllowThreads();
35382 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
35383 wxPyEndAllowThreads(__tstate);
35384 if (PyErr_Occurred()) SWIG_fail;
35385 }
35386 resultobj = SWIG_Py_Void();
35387 if (SWIG_IsTmpObj(res2)) {
35388 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35389 } else {
35390 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35391 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35392 }
35393 if (SWIG_IsTmpObj(res3)) {
35394 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35395 } else {
35396 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35397 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35398 }
35399 return resultobj;
35400 fail:
35401 return NULL;
35402 }
35403
35404
35405 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35406 PyObject *resultobj = 0;
35407 wxWindow *arg1 = (wxWindow *) 0 ;
35408 wxSize result;
35409 void *argp1 = 0 ;
35410 int res1 = 0 ;
35411 PyObject *swig_obj[1] ;
35412
35413 if (!args) SWIG_fail;
35414 swig_obj[0] = args;
35415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35416 if (!SWIG_IsOK(res1)) {
35417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35418 }
35419 arg1 = reinterpret_cast< wxWindow * >(argp1);
35420 {
35421 PyThreadState* __tstate = wxPyBeginAllowThreads();
35422 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
35423 wxPyEndAllowThreads(__tstate);
35424 if (PyErr_Occurred()) SWIG_fail;
35425 }
35426 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35427 return resultobj;
35428 fail:
35429 return NULL;
35430 }
35431
35432
35433 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35434 PyObject *resultobj = 0;
35435 wxWindow *arg1 = (wxWindow *) 0 ;
35436 bool arg2 = (bool) true ;
35437 bool result;
35438 void *argp1 = 0 ;
35439 int res1 = 0 ;
35440 bool val2 ;
35441 int ecode2 = 0 ;
35442 PyObject * obj0 = 0 ;
35443 PyObject * obj1 = 0 ;
35444 char * kwnames[] = {
35445 (char *) "self",(char *) "show", NULL
35446 };
35447
35448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
35449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35450 if (!SWIG_IsOK(res1)) {
35451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
35452 }
35453 arg1 = reinterpret_cast< wxWindow * >(argp1);
35454 if (obj1) {
35455 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35456 if (!SWIG_IsOK(ecode2)) {
35457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
35458 }
35459 arg2 = static_cast< bool >(val2);
35460 }
35461 {
35462 PyThreadState* __tstate = wxPyBeginAllowThreads();
35463 result = (bool)(arg1)->Show(arg2);
35464 wxPyEndAllowThreads(__tstate);
35465 if (PyErr_Occurred()) SWIG_fail;
35466 }
35467 {
35468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35469 }
35470 return resultobj;
35471 fail:
35472 return NULL;
35473 }
35474
35475
35476 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35477 PyObject *resultobj = 0;
35478 wxWindow *arg1 = (wxWindow *) 0 ;
35479 bool result;
35480 void *argp1 = 0 ;
35481 int res1 = 0 ;
35482 PyObject *swig_obj[1] ;
35483
35484 if (!args) SWIG_fail;
35485 swig_obj[0] = args;
35486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35487 if (!SWIG_IsOK(res1)) {
35488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
35489 }
35490 arg1 = reinterpret_cast< wxWindow * >(argp1);
35491 {
35492 PyThreadState* __tstate = wxPyBeginAllowThreads();
35493 result = (bool)(arg1)->Hide();
35494 wxPyEndAllowThreads(__tstate);
35495 if (PyErr_Occurred()) SWIG_fail;
35496 }
35497 {
35498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35499 }
35500 return resultobj;
35501 fail:
35502 return NULL;
35503 }
35504
35505
35506 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35507 PyObject *resultobj = 0;
35508 wxWindow *arg1 = (wxWindow *) 0 ;
35509 bool arg2 = (bool) true ;
35510 bool result;
35511 void *argp1 = 0 ;
35512 int res1 = 0 ;
35513 bool val2 ;
35514 int ecode2 = 0 ;
35515 PyObject * obj0 = 0 ;
35516 PyObject * obj1 = 0 ;
35517 char * kwnames[] = {
35518 (char *) "self",(char *) "enable", NULL
35519 };
35520
35521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
35522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35523 if (!SWIG_IsOK(res1)) {
35524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
35525 }
35526 arg1 = reinterpret_cast< wxWindow * >(argp1);
35527 if (obj1) {
35528 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35529 if (!SWIG_IsOK(ecode2)) {
35530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
35531 }
35532 arg2 = static_cast< bool >(val2);
35533 }
35534 {
35535 PyThreadState* __tstate = wxPyBeginAllowThreads();
35536 result = (bool)(arg1)->Enable(arg2);
35537 wxPyEndAllowThreads(__tstate);
35538 if (PyErr_Occurred()) SWIG_fail;
35539 }
35540 {
35541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35542 }
35543 return resultobj;
35544 fail:
35545 return NULL;
35546 }
35547
35548
35549 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35550 PyObject *resultobj = 0;
35551 wxWindow *arg1 = (wxWindow *) 0 ;
35552 bool result;
35553 void *argp1 = 0 ;
35554 int res1 = 0 ;
35555 PyObject *swig_obj[1] ;
35556
35557 if (!args) SWIG_fail;
35558 swig_obj[0] = args;
35559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35560 if (!SWIG_IsOK(res1)) {
35561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
35562 }
35563 arg1 = reinterpret_cast< wxWindow * >(argp1);
35564 {
35565 PyThreadState* __tstate = wxPyBeginAllowThreads();
35566 result = (bool)(arg1)->Disable();
35567 wxPyEndAllowThreads(__tstate);
35568 if (PyErr_Occurred()) SWIG_fail;
35569 }
35570 {
35571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35572 }
35573 return resultobj;
35574 fail:
35575 return NULL;
35576 }
35577
35578
35579 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35580 PyObject *resultobj = 0;
35581 wxWindow *arg1 = (wxWindow *) 0 ;
35582 bool result;
35583 void *argp1 = 0 ;
35584 int res1 = 0 ;
35585 PyObject *swig_obj[1] ;
35586
35587 if (!args) SWIG_fail;
35588 swig_obj[0] = args;
35589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35590 if (!SWIG_IsOK(res1)) {
35591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
35592 }
35593 arg1 = reinterpret_cast< wxWindow * >(argp1);
35594 {
35595 PyThreadState* __tstate = wxPyBeginAllowThreads();
35596 result = (bool)((wxWindow const *)arg1)->IsShown();
35597 wxPyEndAllowThreads(__tstate);
35598 if (PyErr_Occurred()) SWIG_fail;
35599 }
35600 {
35601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35602 }
35603 return resultobj;
35604 fail:
35605 return NULL;
35606 }
35607
35608
35609 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35610 PyObject *resultobj = 0;
35611 wxWindow *arg1 = (wxWindow *) 0 ;
35612 bool result;
35613 void *argp1 = 0 ;
35614 int res1 = 0 ;
35615 PyObject *swig_obj[1] ;
35616
35617 if (!args) SWIG_fail;
35618 swig_obj[0] = args;
35619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35620 if (!SWIG_IsOK(res1)) {
35621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35622 }
35623 arg1 = reinterpret_cast< wxWindow * >(argp1);
35624 {
35625 PyThreadState* __tstate = wxPyBeginAllowThreads();
35626 result = (bool)((wxWindow const *)arg1)->IsEnabled();
35627 wxPyEndAllowThreads(__tstate);
35628 if (PyErr_Occurred()) SWIG_fail;
35629 }
35630 {
35631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35632 }
35633 return resultobj;
35634 fail:
35635 return NULL;
35636 }
35637
35638
35639 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35640 PyObject *resultobj = 0;
35641 wxWindow *arg1 = (wxWindow *) 0 ;
35642 bool result;
35643 void *argp1 = 0 ;
35644 int res1 = 0 ;
35645 PyObject *swig_obj[1] ;
35646
35647 if (!args) SWIG_fail;
35648 swig_obj[0] = args;
35649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35650 if (!SWIG_IsOK(res1)) {
35651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35652 }
35653 arg1 = reinterpret_cast< wxWindow * >(argp1);
35654 {
35655 PyThreadState* __tstate = wxPyBeginAllowThreads();
35656 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
35657 wxPyEndAllowThreads(__tstate);
35658 if (PyErr_Occurred()) SWIG_fail;
35659 }
35660 {
35661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35662 }
35663 return resultobj;
35664 fail:
35665 return NULL;
35666 }
35667
35668
35669 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35670 PyObject *resultobj = 0;
35671 wxWindow *arg1 = (wxWindow *) 0 ;
35672 long arg2 ;
35673 void *argp1 = 0 ;
35674 int res1 = 0 ;
35675 long val2 ;
35676 int ecode2 = 0 ;
35677 PyObject * obj0 = 0 ;
35678 PyObject * obj1 = 0 ;
35679 char * kwnames[] = {
35680 (char *) "self",(char *) "style", NULL
35681 };
35682
35683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35685 if (!SWIG_IsOK(res1)) {
35686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
35687 }
35688 arg1 = reinterpret_cast< wxWindow * >(argp1);
35689 ecode2 = SWIG_AsVal_long(obj1, &val2);
35690 if (!SWIG_IsOK(ecode2)) {
35691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
35692 }
35693 arg2 = static_cast< long >(val2);
35694 {
35695 PyThreadState* __tstate = wxPyBeginAllowThreads();
35696 (arg1)->SetWindowStyleFlag(arg2);
35697 wxPyEndAllowThreads(__tstate);
35698 if (PyErr_Occurred()) SWIG_fail;
35699 }
35700 resultobj = SWIG_Py_Void();
35701 return resultobj;
35702 fail:
35703 return NULL;
35704 }
35705
35706
35707 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35708 PyObject *resultobj = 0;
35709 wxWindow *arg1 = (wxWindow *) 0 ;
35710 long result;
35711 void *argp1 = 0 ;
35712 int res1 = 0 ;
35713 PyObject *swig_obj[1] ;
35714
35715 if (!args) SWIG_fail;
35716 swig_obj[0] = args;
35717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35718 if (!SWIG_IsOK(res1)) {
35719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35720 }
35721 arg1 = reinterpret_cast< wxWindow * >(argp1);
35722 {
35723 PyThreadState* __tstate = wxPyBeginAllowThreads();
35724 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
35725 wxPyEndAllowThreads(__tstate);
35726 if (PyErr_Occurred()) SWIG_fail;
35727 }
35728 resultobj = SWIG_From_long(static_cast< long >(result));
35729 return resultobj;
35730 fail:
35731 return NULL;
35732 }
35733
35734
35735 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35736 PyObject *resultobj = 0;
35737 wxWindow *arg1 = (wxWindow *) 0 ;
35738 int arg2 ;
35739 bool result;
35740 void *argp1 = 0 ;
35741 int res1 = 0 ;
35742 int val2 ;
35743 int ecode2 = 0 ;
35744 PyObject * obj0 = 0 ;
35745 PyObject * obj1 = 0 ;
35746 char * kwnames[] = {
35747 (char *) "self",(char *) "flag", NULL
35748 };
35749
35750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35752 if (!SWIG_IsOK(res1)) {
35753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35754 }
35755 arg1 = reinterpret_cast< wxWindow * >(argp1);
35756 ecode2 = SWIG_AsVal_int(obj1, &val2);
35757 if (!SWIG_IsOK(ecode2)) {
35758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
35759 }
35760 arg2 = static_cast< int >(val2);
35761 {
35762 PyThreadState* __tstate = wxPyBeginAllowThreads();
35763 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
35764 wxPyEndAllowThreads(__tstate);
35765 if (PyErr_Occurred()) SWIG_fail;
35766 }
35767 {
35768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35769 }
35770 return resultobj;
35771 fail:
35772 return NULL;
35773 }
35774
35775
35776 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35777 PyObject *resultobj = 0;
35778 wxWindow *arg1 = (wxWindow *) 0 ;
35779 bool result;
35780 void *argp1 = 0 ;
35781 int res1 = 0 ;
35782 PyObject *swig_obj[1] ;
35783
35784 if (!args) SWIG_fail;
35785 swig_obj[0] = args;
35786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35787 if (!SWIG_IsOK(res1)) {
35788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
35789 }
35790 arg1 = reinterpret_cast< wxWindow * >(argp1);
35791 {
35792 PyThreadState* __tstate = wxPyBeginAllowThreads();
35793 result = (bool)((wxWindow const *)arg1)->IsRetained();
35794 wxPyEndAllowThreads(__tstate);
35795 if (PyErr_Occurred()) SWIG_fail;
35796 }
35797 {
35798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35799 }
35800 return resultobj;
35801 fail:
35802 return NULL;
35803 }
35804
35805
35806 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35807 PyObject *resultobj = 0;
35808 wxWindow *arg1 = (wxWindow *) 0 ;
35809 long arg2 ;
35810 void *argp1 = 0 ;
35811 int res1 = 0 ;
35812 long val2 ;
35813 int ecode2 = 0 ;
35814 PyObject * obj0 = 0 ;
35815 PyObject * obj1 = 0 ;
35816 char * kwnames[] = {
35817 (char *) "self",(char *) "exStyle", NULL
35818 };
35819
35820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35822 if (!SWIG_IsOK(res1)) {
35823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35824 }
35825 arg1 = reinterpret_cast< wxWindow * >(argp1);
35826 ecode2 = SWIG_AsVal_long(obj1, &val2);
35827 if (!SWIG_IsOK(ecode2)) {
35828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
35829 }
35830 arg2 = static_cast< long >(val2);
35831 {
35832 PyThreadState* __tstate = wxPyBeginAllowThreads();
35833 (arg1)->SetExtraStyle(arg2);
35834 wxPyEndAllowThreads(__tstate);
35835 if (PyErr_Occurred()) SWIG_fail;
35836 }
35837 resultobj = SWIG_Py_Void();
35838 return resultobj;
35839 fail:
35840 return NULL;
35841 }
35842
35843
35844 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35845 PyObject *resultobj = 0;
35846 wxWindow *arg1 = (wxWindow *) 0 ;
35847 long result;
35848 void *argp1 = 0 ;
35849 int res1 = 0 ;
35850 PyObject *swig_obj[1] ;
35851
35852 if (!args) SWIG_fail;
35853 swig_obj[0] = args;
35854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35855 if (!SWIG_IsOK(res1)) {
35856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35857 }
35858 arg1 = reinterpret_cast< wxWindow * >(argp1);
35859 {
35860 PyThreadState* __tstate = wxPyBeginAllowThreads();
35861 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
35862 wxPyEndAllowThreads(__tstate);
35863 if (PyErr_Occurred()) SWIG_fail;
35864 }
35865 resultobj = SWIG_From_long(static_cast< long >(result));
35866 return resultobj;
35867 fail:
35868 return NULL;
35869 }
35870
35871
35872 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35873 PyObject *resultobj = 0;
35874 wxWindow *arg1 = (wxWindow *) 0 ;
35875 bool arg2 = (bool) true ;
35876 void *argp1 = 0 ;
35877 int res1 = 0 ;
35878 bool val2 ;
35879 int ecode2 = 0 ;
35880 PyObject * obj0 = 0 ;
35881 PyObject * obj1 = 0 ;
35882 char * kwnames[] = {
35883 (char *) "self",(char *) "modal", NULL
35884 };
35885
35886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
35887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35888 if (!SWIG_IsOK(res1)) {
35889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
35890 }
35891 arg1 = reinterpret_cast< wxWindow * >(argp1);
35892 if (obj1) {
35893 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35894 if (!SWIG_IsOK(ecode2)) {
35895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
35896 }
35897 arg2 = static_cast< bool >(val2);
35898 }
35899 {
35900 PyThreadState* __tstate = wxPyBeginAllowThreads();
35901 (arg1)->MakeModal(arg2);
35902 wxPyEndAllowThreads(__tstate);
35903 if (PyErr_Occurred()) SWIG_fail;
35904 }
35905 resultobj = SWIG_Py_Void();
35906 return resultobj;
35907 fail:
35908 return NULL;
35909 }
35910
35911
35912 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35913 PyObject *resultobj = 0;
35914 wxWindow *arg1 = (wxWindow *) 0 ;
35915 bool arg2 ;
35916 void *argp1 = 0 ;
35917 int res1 = 0 ;
35918 bool val2 ;
35919 int ecode2 = 0 ;
35920 PyObject * obj0 = 0 ;
35921 PyObject * obj1 = 0 ;
35922 char * kwnames[] = {
35923 (char *) "self",(char *) "enableTheme", NULL
35924 };
35925
35926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
35927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35928 if (!SWIG_IsOK(res1)) {
35929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
35930 }
35931 arg1 = reinterpret_cast< wxWindow * >(argp1);
35932 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35933 if (!SWIG_IsOK(ecode2)) {
35934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
35935 }
35936 arg2 = static_cast< bool >(val2);
35937 {
35938 PyThreadState* __tstate = wxPyBeginAllowThreads();
35939 (arg1)->SetThemeEnabled(arg2);
35940 wxPyEndAllowThreads(__tstate);
35941 if (PyErr_Occurred()) SWIG_fail;
35942 }
35943 resultobj = SWIG_Py_Void();
35944 return resultobj;
35945 fail:
35946 return NULL;
35947 }
35948
35949
35950 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35951 PyObject *resultobj = 0;
35952 wxWindow *arg1 = (wxWindow *) 0 ;
35953 bool result;
35954 void *argp1 = 0 ;
35955 int res1 = 0 ;
35956 PyObject *swig_obj[1] ;
35957
35958 if (!args) SWIG_fail;
35959 swig_obj[0] = args;
35960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35961 if (!SWIG_IsOK(res1)) {
35962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35963 }
35964 arg1 = reinterpret_cast< wxWindow * >(argp1);
35965 {
35966 PyThreadState* __tstate = wxPyBeginAllowThreads();
35967 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
35968 wxPyEndAllowThreads(__tstate);
35969 if (PyErr_Occurred()) SWIG_fail;
35970 }
35971 {
35972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35973 }
35974 return resultobj;
35975 fail:
35976 return NULL;
35977 }
35978
35979
35980 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35981 PyObject *resultobj = 0;
35982 wxWindow *arg1 = (wxWindow *) 0 ;
35983 void *argp1 = 0 ;
35984 int res1 = 0 ;
35985 PyObject *swig_obj[1] ;
35986
35987 if (!args) SWIG_fail;
35988 swig_obj[0] = args;
35989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35990 if (!SWIG_IsOK(res1)) {
35991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
35992 }
35993 arg1 = reinterpret_cast< wxWindow * >(argp1);
35994 {
35995 PyThreadState* __tstate = wxPyBeginAllowThreads();
35996 (arg1)->SetFocus();
35997 wxPyEndAllowThreads(__tstate);
35998 if (PyErr_Occurred()) SWIG_fail;
35999 }
36000 resultobj = SWIG_Py_Void();
36001 return resultobj;
36002 fail:
36003 return NULL;
36004 }
36005
36006
36007 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36008 PyObject *resultobj = 0;
36009 wxWindow *arg1 = (wxWindow *) 0 ;
36010 void *argp1 = 0 ;
36011 int res1 = 0 ;
36012 PyObject *swig_obj[1] ;
36013
36014 if (!args) SWIG_fail;
36015 swig_obj[0] = args;
36016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36017 if (!SWIG_IsOK(res1)) {
36018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
36019 }
36020 arg1 = reinterpret_cast< wxWindow * >(argp1);
36021 {
36022 PyThreadState* __tstate = wxPyBeginAllowThreads();
36023 (arg1)->SetFocusFromKbd();
36024 wxPyEndAllowThreads(__tstate);
36025 if (PyErr_Occurred()) SWIG_fail;
36026 }
36027 resultobj = SWIG_Py_Void();
36028 return resultobj;
36029 fail:
36030 return NULL;
36031 }
36032
36033
36034 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36035 PyObject *resultobj = 0;
36036 wxWindow *result = 0 ;
36037
36038 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
36039 {
36040 if (!wxPyCheckForApp()) SWIG_fail;
36041 PyThreadState* __tstate = wxPyBeginAllowThreads();
36042 result = (wxWindow *)wxWindow::FindFocus();
36043 wxPyEndAllowThreads(__tstate);
36044 if (PyErr_Occurred()) SWIG_fail;
36045 }
36046 {
36047 resultobj = wxPyMake_wxObject(result, 0);
36048 }
36049 return resultobj;
36050 fail:
36051 return NULL;
36052 }
36053
36054
36055 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36056 PyObject *resultobj = 0;
36057 wxWindow *arg1 = (wxWindow *) 0 ;
36058 bool result;
36059 void *argp1 = 0 ;
36060 int res1 = 0 ;
36061 PyObject *swig_obj[1] ;
36062
36063 if (!args) SWIG_fail;
36064 swig_obj[0] = args;
36065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36066 if (!SWIG_IsOK(res1)) {
36067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36068 }
36069 arg1 = reinterpret_cast< wxWindow * >(argp1);
36070 {
36071 PyThreadState* __tstate = wxPyBeginAllowThreads();
36072 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
36073 wxPyEndAllowThreads(__tstate);
36074 if (PyErr_Occurred()) SWIG_fail;
36075 }
36076 {
36077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36078 }
36079 return resultobj;
36080 fail:
36081 return NULL;
36082 }
36083
36084
36085 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36086 PyObject *resultobj = 0;
36087 wxWindow *arg1 = (wxWindow *) 0 ;
36088 bool result;
36089 void *argp1 = 0 ;
36090 int res1 = 0 ;
36091 PyObject *swig_obj[1] ;
36092
36093 if (!args) SWIG_fail;
36094 swig_obj[0] = args;
36095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36096 if (!SWIG_IsOK(res1)) {
36097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36098 }
36099 arg1 = reinterpret_cast< wxWindow * >(argp1);
36100 {
36101 PyThreadState* __tstate = wxPyBeginAllowThreads();
36102 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
36103 wxPyEndAllowThreads(__tstate);
36104 if (PyErr_Occurred()) SWIG_fail;
36105 }
36106 {
36107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36108 }
36109 return resultobj;
36110 fail:
36111 return NULL;
36112 }
36113
36114
36115 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36116 PyObject *resultobj = 0;
36117 wxWindow *arg1 = (wxWindow *) 0 ;
36118 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
36119 bool result;
36120 void *argp1 = 0 ;
36121 int res1 = 0 ;
36122 int val2 ;
36123 int ecode2 = 0 ;
36124 PyObject * obj0 = 0 ;
36125 PyObject * obj1 = 0 ;
36126 char * kwnames[] = {
36127 (char *) "self",(char *) "flags", NULL
36128 };
36129
36130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
36131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36132 if (!SWIG_IsOK(res1)) {
36133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
36134 }
36135 arg1 = reinterpret_cast< wxWindow * >(argp1);
36136 if (obj1) {
36137 ecode2 = SWIG_AsVal_int(obj1, &val2);
36138 if (!SWIG_IsOK(ecode2)) {
36139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
36140 }
36141 arg2 = static_cast< int >(val2);
36142 }
36143 {
36144 PyThreadState* __tstate = wxPyBeginAllowThreads();
36145 result = (bool)(arg1)->Navigate(arg2);
36146 wxPyEndAllowThreads(__tstate);
36147 if (PyErr_Occurred()) SWIG_fail;
36148 }
36149 {
36150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36151 }
36152 return resultobj;
36153 fail:
36154 return NULL;
36155 }
36156
36157
36158 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36159 PyObject *resultobj = 0;
36160 wxWindow *arg1 = (wxWindow *) 0 ;
36161 wxWindow *arg2 = (wxWindow *) 0 ;
36162 void *argp1 = 0 ;
36163 int res1 = 0 ;
36164 void *argp2 = 0 ;
36165 int res2 = 0 ;
36166 PyObject * obj0 = 0 ;
36167 PyObject * obj1 = 0 ;
36168 char * kwnames[] = {
36169 (char *) "self",(char *) "win", NULL
36170 };
36171
36172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36174 if (!SWIG_IsOK(res1)) {
36175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36176 }
36177 arg1 = reinterpret_cast< wxWindow * >(argp1);
36178 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36179 if (!SWIG_IsOK(res2)) {
36180 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36181 }
36182 arg2 = reinterpret_cast< wxWindow * >(argp2);
36183 {
36184 PyThreadState* __tstate = wxPyBeginAllowThreads();
36185 (arg1)->MoveAfterInTabOrder(arg2);
36186 wxPyEndAllowThreads(__tstate);
36187 if (PyErr_Occurred()) SWIG_fail;
36188 }
36189 resultobj = SWIG_Py_Void();
36190 return resultobj;
36191 fail:
36192 return NULL;
36193 }
36194
36195
36196 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36197 PyObject *resultobj = 0;
36198 wxWindow *arg1 = (wxWindow *) 0 ;
36199 wxWindow *arg2 = (wxWindow *) 0 ;
36200 void *argp1 = 0 ;
36201 int res1 = 0 ;
36202 void *argp2 = 0 ;
36203 int res2 = 0 ;
36204 PyObject * obj0 = 0 ;
36205 PyObject * obj1 = 0 ;
36206 char * kwnames[] = {
36207 (char *) "self",(char *) "win", NULL
36208 };
36209
36210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36212 if (!SWIG_IsOK(res1)) {
36213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36214 }
36215 arg1 = reinterpret_cast< wxWindow * >(argp1);
36216 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36217 if (!SWIG_IsOK(res2)) {
36218 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36219 }
36220 arg2 = reinterpret_cast< wxWindow * >(argp2);
36221 {
36222 PyThreadState* __tstate = wxPyBeginAllowThreads();
36223 (arg1)->MoveBeforeInTabOrder(arg2);
36224 wxPyEndAllowThreads(__tstate);
36225 if (PyErr_Occurred()) SWIG_fail;
36226 }
36227 resultobj = SWIG_Py_Void();
36228 return resultobj;
36229 fail:
36230 return NULL;
36231 }
36232
36233
36234 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36235 PyObject *resultobj = 0;
36236 wxWindow *arg1 = (wxWindow *) 0 ;
36237 PyObject *result = 0 ;
36238 void *argp1 = 0 ;
36239 int res1 = 0 ;
36240 PyObject *swig_obj[1] ;
36241
36242 if (!args) SWIG_fail;
36243 swig_obj[0] = args;
36244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36245 if (!SWIG_IsOK(res1)) {
36246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
36247 }
36248 arg1 = reinterpret_cast< wxWindow * >(argp1);
36249 {
36250 PyThreadState* __tstate = wxPyBeginAllowThreads();
36251 result = (PyObject *)wxWindow_GetChildren(arg1);
36252 wxPyEndAllowThreads(__tstate);
36253 if (PyErr_Occurred()) SWIG_fail;
36254 }
36255 resultobj = result;
36256 return resultobj;
36257 fail:
36258 return NULL;
36259 }
36260
36261
36262 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36263 PyObject *resultobj = 0;
36264 wxWindow *arg1 = (wxWindow *) 0 ;
36265 wxWindow *result = 0 ;
36266 void *argp1 = 0 ;
36267 int res1 = 0 ;
36268 PyObject *swig_obj[1] ;
36269
36270 if (!args) SWIG_fail;
36271 swig_obj[0] = args;
36272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36273 if (!SWIG_IsOK(res1)) {
36274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36275 }
36276 arg1 = reinterpret_cast< wxWindow * >(argp1);
36277 {
36278 PyThreadState* __tstate = wxPyBeginAllowThreads();
36279 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
36280 wxPyEndAllowThreads(__tstate);
36281 if (PyErr_Occurred()) SWIG_fail;
36282 }
36283 {
36284 resultobj = wxPyMake_wxObject(result, 0);
36285 }
36286 return resultobj;
36287 fail:
36288 return NULL;
36289 }
36290
36291
36292 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36293 PyObject *resultobj = 0;
36294 wxWindow *arg1 = (wxWindow *) 0 ;
36295 wxWindow *result = 0 ;
36296 void *argp1 = 0 ;
36297 int res1 = 0 ;
36298 PyObject *swig_obj[1] ;
36299
36300 if (!args) SWIG_fail;
36301 swig_obj[0] = args;
36302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36303 if (!SWIG_IsOK(res1)) {
36304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36305 }
36306 arg1 = reinterpret_cast< wxWindow * >(argp1);
36307 {
36308 PyThreadState* __tstate = wxPyBeginAllowThreads();
36309 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
36310 wxPyEndAllowThreads(__tstate);
36311 if (PyErr_Occurred()) SWIG_fail;
36312 }
36313 {
36314 resultobj = wxPyMake_wxObject(result, 0);
36315 }
36316 return resultobj;
36317 fail:
36318 return NULL;
36319 }
36320
36321
36322 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36323 PyObject *resultobj = 0;
36324 wxWindow *arg1 = (wxWindow *) 0 ;
36325 bool result;
36326 void *argp1 = 0 ;
36327 int res1 = 0 ;
36328 PyObject *swig_obj[1] ;
36329
36330 if (!args) SWIG_fail;
36331 swig_obj[0] = args;
36332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36333 if (!SWIG_IsOK(res1)) {
36334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
36335 }
36336 arg1 = reinterpret_cast< wxWindow * >(argp1);
36337 {
36338 PyThreadState* __tstate = wxPyBeginAllowThreads();
36339 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
36340 wxPyEndAllowThreads(__tstate);
36341 if (PyErr_Occurred()) SWIG_fail;
36342 }
36343 {
36344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36345 }
36346 return resultobj;
36347 fail:
36348 return NULL;
36349 }
36350
36351
36352 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36353 PyObject *resultobj = 0;
36354 wxWindow *arg1 = (wxWindow *) 0 ;
36355 wxWindow *arg2 = (wxWindow *) 0 ;
36356 bool result;
36357 void *argp1 = 0 ;
36358 int res1 = 0 ;
36359 void *argp2 = 0 ;
36360 int res2 = 0 ;
36361 PyObject * obj0 = 0 ;
36362 PyObject * obj1 = 0 ;
36363 char * kwnames[] = {
36364 (char *) "self",(char *) "newParent", NULL
36365 };
36366
36367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
36368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36369 if (!SWIG_IsOK(res1)) {
36370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
36371 }
36372 arg1 = reinterpret_cast< wxWindow * >(argp1);
36373 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36374 if (!SWIG_IsOK(res2)) {
36375 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
36376 }
36377 arg2 = reinterpret_cast< wxWindow * >(argp2);
36378 {
36379 PyThreadState* __tstate = wxPyBeginAllowThreads();
36380 result = (bool)(arg1)->Reparent(arg2);
36381 wxPyEndAllowThreads(__tstate);
36382 if (PyErr_Occurred()) SWIG_fail;
36383 }
36384 {
36385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36386 }
36387 return resultobj;
36388 fail:
36389 return NULL;
36390 }
36391
36392
36393 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36394 PyObject *resultobj = 0;
36395 wxWindow *arg1 = (wxWindow *) 0 ;
36396 wxWindow *arg2 = (wxWindow *) 0 ;
36397 void *argp1 = 0 ;
36398 int res1 = 0 ;
36399 void *argp2 = 0 ;
36400 int res2 = 0 ;
36401 PyObject * obj0 = 0 ;
36402 PyObject * obj1 = 0 ;
36403 char * kwnames[] = {
36404 (char *) "self",(char *) "child", NULL
36405 };
36406
36407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
36408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36409 if (!SWIG_IsOK(res1)) {
36410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36411 }
36412 arg1 = reinterpret_cast< wxWindow * >(argp1);
36413 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36414 if (!SWIG_IsOK(res2)) {
36415 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36416 }
36417 arg2 = reinterpret_cast< wxWindow * >(argp2);
36418 {
36419 PyThreadState* __tstate = wxPyBeginAllowThreads();
36420 (arg1)->AddChild(arg2);
36421 wxPyEndAllowThreads(__tstate);
36422 if (PyErr_Occurred()) SWIG_fail;
36423 }
36424 resultobj = SWIG_Py_Void();
36425 return resultobj;
36426 fail:
36427 return NULL;
36428 }
36429
36430
36431 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36432 PyObject *resultobj = 0;
36433 wxWindow *arg1 = (wxWindow *) 0 ;
36434 wxWindow *arg2 = (wxWindow *) 0 ;
36435 void *argp1 = 0 ;
36436 int res1 = 0 ;
36437 void *argp2 = 0 ;
36438 int res2 = 0 ;
36439 PyObject * obj0 = 0 ;
36440 PyObject * obj1 = 0 ;
36441 char * kwnames[] = {
36442 (char *) "self",(char *) "child", NULL
36443 };
36444
36445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
36446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36447 if (!SWIG_IsOK(res1)) {
36448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36449 }
36450 arg1 = reinterpret_cast< wxWindow * >(argp1);
36451 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36452 if (!SWIG_IsOK(res2)) {
36453 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36454 }
36455 arg2 = reinterpret_cast< wxWindow * >(argp2);
36456 {
36457 PyThreadState* __tstate = wxPyBeginAllowThreads();
36458 (arg1)->RemoveChild(arg2);
36459 wxPyEndAllowThreads(__tstate);
36460 if (PyErr_Occurred()) SWIG_fail;
36461 }
36462 resultobj = SWIG_Py_Void();
36463 return resultobj;
36464 fail:
36465 return NULL;
36466 }
36467
36468
36469 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36470 PyObject *resultobj = 0;
36471 wxWindow *arg1 = (wxWindow *) 0 ;
36472 bool arg2 ;
36473 void *argp1 = 0 ;
36474 int res1 = 0 ;
36475 bool val2 ;
36476 int ecode2 = 0 ;
36477 PyObject * obj0 = 0 ;
36478 PyObject * obj1 = 0 ;
36479 char * kwnames[] = {
36480 (char *) "self",(char *) "on", NULL
36481 };
36482
36483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
36484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36485 if (!SWIG_IsOK(res1)) {
36486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
36487 }
36488 arg1 = reinterpret_cast< wxWindow * >(argp1);
36489 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36490 if (!SWIG_IsOK(ecode2)) {
36491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
36492 }
36493 arg2 = static_cast< bool >(val2);
36494 {
36495 PyThreadState* __tstate = wxPyBeginAllowThreads();
36496 (arg1)->SetDoubleBuffered(arg2);
36497 wxPyEndAllowThreads(__tstate);
36498 if (PyErr_Occurred()) SWIG_fail;
36499 }
36500 resultobj = SWIG_Py_Void();
36501 return resultobj;
36502 fail:
36503 return NULL;
36504 }
36505
36506
36507 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36508 PyObject *resultobj = 0;
36509 wxWindow *arg1 = (wxWindow *) 0 ;
36510 long arg2 ;
36511 wxWindow *result = 0 ;
36512 void *argp1 = 0 ;
36513 int res1 = 0 ;
36514 long val2 ;
36515 int ecode2 = 0 ;
36516 PyObject * obj0 = 0 ;
36517 PyObject * obj1 = 0 ;
36518 char * kwnames[] = {
36519 (char *) "self",(char *) "winid", NULL
36520 };
36521
36522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
36523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36524 if (!SWIG_IsOK(res1)) {
36525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
36526 }
36527 arg1 = reinterpret_cast< wxWindow * >(argp1);
36528 ecode2 = SWIG_AsVal_long(obj1, &val2);
36529 if (!SWIG_IsOK(ecode2)) {
36530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
36531 }
36532 arg2 = static_cast< long >(val2);
36533 {
36534 PyThreadState* __tstate = wxPyBeginAllowThreads();
36535 result = (wxWindow *)(arg1)->FindWindow(arg2);
36536 wxPyEndAllowThreads(__tstate);
36537 if (PyErr_Occurred()) SWIG_fail;
36538 }
36539 {
36540 resultobj = wxPyMake_wxObject(result, 0);
36541 }
36542 return resultobj;
36543 fail:
36544 return NULL;
36545 }
36546
36547
36548 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36549 PyObject *resultobj = 0;
36550 wxWindow *arg1 = (wxWindow *) 0 ;
36551 wxString *arg2 = 0 ;
36552 wxWindow *result = 0 ;
36553 void *argp1 = 0 ;
36554 int res1 = 0 ;
36555 bool temp2 = false ;
36556 PyObject * obj0 = 0 ;
36557 PyObject * obj1 = 0 ;
36558 char * kwnames[] = {
36559 (char *) "self",(char *) "name", NULL
36560 };
36561
36562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
36563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36564 if (!SWIG_IsOK(res1)) {
36565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
36566 }
36567 arg1 = reinterpret_cast< wxWindow * >(argp1);
36568 {
36569 arg2 = wxString_in_helper(obj1);
36570 if (arg2 == NULL) SWIG_fail;
36571 temp2 = true;
36572 }
36573 {
36574 PyThreadState* __tstate = wxPyBeginAllowThreads();
36575 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
36576 wxPyEndAllowThreads(__tstate);
36577 if (PyErr_Occurred()) SWIG_fail;
36578 }
36579 {
36580 resultobj = wxPyMake_wxObject(result, 0);
36581 }
36582 {
36583 if (temp2)
36584 delete arg2;
36585 }
36586 return resultobj;
36587 fail:
36588 {
36589 if (temp2)
36590 delete arg2;
36591 }
36592 return NULL;
36593 }
36594
36595
36596 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36597 PyObject *resultobj = 0;
36598 wxWindow *arg1 = (wxWindow *) 0 ;
36599 wxEvtHandler *result = 0 ;
36600 void *argp1 = 0 ;
36601 int res1 = 0 ;
36602 PyObject *swig_obj[1] ;
36603
36604 if (!args) SWIG_fail;
36605 swig_obj[0] = args;
36606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36607 if (!SWIG_IsOK(res1)) {
36608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
36609 }
36610 arg1 = reinterpret_cast< wxWindow * >(argp1);
36611 {
36612 PyThreadState* __tstate = wxPyBeginAllowThreads();
36613 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
36614 wxPyEndAllowThreads(__tstate);
36615 if (PyErr_Occurred()) SWIG_fail;
36616 }
36617 {
36618 resultobj = wxPyMake_wxObject(result, 0);
36619 }
36620 return resultobj;
36621 fail:
36622 return NULL;
36623 }
36624
36625
36626 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36627 PyObject *resultobj = 0;
36628 wxWindow *arg1 = (wxWindow *) 0 ;
36629 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36630 void *argp1 = 0 ;
36631 int res1 = 0 ;
36632 void *argp2 = 0 ;
36633 int res2 = 0 ;
36634 PyObject * obj0 = 0 ;
36635 PyObject * obj1 = 0 ;
36636 char * kwnames[] = {
36637 (char *) "self",(char *) "handler", NULL
36638 };
36639
36640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36642 if (!SWIG_IsOK(res1)) {
36643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36644 }
36645 arg1 = reinterpret_cast< wxWindow * >(argp1);
36646 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36647 if (!SWIG_IsOK(res2)) {
36648 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36649 }
36650 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36651 {
36652 PyThreadState* __tstate = wxPyBeginAllowThreads();
36653 (arg1)->SetEventHandler(arg2);
36654 wxPyEndAllowThreads(__tstate);
36655 if (PyErr_Occurred()) SWIG_fail;
36656 }
36657 resultobj = SWIG_Py_Void();
36658 return resultobj;
36659 fail:
36660 return NULL;
36661 }
36662
36663
36664 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36665 PyObject *resultobj = 0;
36666 wxWindow *arg1 = (wxWindow *) 0 ;
36667 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36668 void *argp1 = 0 ;
36669 int res1 = 0 ;
36670 void *argp2 = 0 ;
36671 int res2 = 0 ;
36672 PyObject * obj0 = 0 ;
36673 PyObject * obj1 = 0 ;
36674 char * kwnames[] = {
36675 (char *) "self",(char *) "handler", NULL
36676 };
36677
36678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36680 if (!SWIG_IsOK(res1)) {
36681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36682 }
36683 arg1 = reinterpret_cast< wxWindow * >(argp1);
36684 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36685 if (!SWIG_IsOK(res2)) {
36686 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36687 }
36688 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36689 {
36690 PyThreadState* __tstate = wxPyBeginAllowThreads();
36691 (arg1)->PushEventHandler(arg2);
36692 wxPyEndAllowThreads(__tstate);
36693 if (PyErr_Occurred()) SWIG_fail;
36694 }
36695 resultobj = SWIG_Py_Void();
36696 return resultobj;
36697 fail:
36698 return NULL;
36699 }
36700
36701
36702 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36703 PyObject *resultobj = 0;
36704 wxWindow *arg1 = (wxWindow *) 0 ;
36705 bool arg2 = (bool) false ;
36706 wxEvtHandler *result = 0 ;
36707 void *argp1 = 0 ;
36708 int res1 = 0 ;
36709 bool val2 ;
36710 int ecode2 = 0 ;
36711 PyObject * obj0 = 0 ;
36712 PyObject * obj1 = 0 ;
36713 char * kwnames[] = {
36714 (char *) "self",(char *) "deleteHandler", NULL
36715 };
36716
36717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36719 if (!SWIG_IsOK(res1)) {
36720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36721 }
36722 arg1 = reinterpret_cast< wxWindow * >(argp1);
36723 if (obj1) {
36724 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36725 if (!SWIG_IsOK(ecode2)) {
36726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
36727 }
36728 arg2 = static_cast< bool >(val2);
36729 }
36730 {
36731 PyThreadState* __tstate = wxPyBeginAllowThreads();
36732 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
36733 wxPyEndAllowThreads(__tstate);
36734 if (PyErr_Occurred()) SWIG_fail;
36735 }
36736 {
36737 resultobj = wxPyMake_wxObject(result, 0);
36738 }
36739 return resultobj;
36740 fail:
36741 return NULL;
36742 }
36743
36744
36745 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36746 PyObject *resultobj = 0;
36747 wxWindow *arg1 = (wxWindow *) 0 ;
36748 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36749 bool result;
36750 void *argp1 = 0 ;
36751 int res1 = 0 ;
36752 void *argp2 = 0 ;
36753 int res2 = 0 ;
36754 PyObject * obj0 = 0 ;
36755 PyObject * obj1 = 0 ;
36756 char * kwnames[] = {
36757 (char *) "self",(char *) "handler", NULL
36758 };
36759
36760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36762 if (!SWIG_IsOK(res1)) {
36763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36764 }
36765 arg1 = reinterpret_cast< wxWindow * >(argp1);
36766 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36767 if (!SWIG_IsOK(res2)) {
36768 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36769 }
36770 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36771 {
36772 PyThreadState* __tstate = wxPyBeginAllowThreads();
36773 result = (bool)(arg1)->RemoveEventHandler(arg2);
36774 wxPyEndAllowThreads(__tstate);
36775 if (PyErr_Occurred()) SWIG_fail;
36776 }
36777 {
36778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36779 }
36780 return resultobj;
36781 fail:
36782 return NULL;
36783 }
36784
36785
36786 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36787 PyObject *resultobj = 0;
36788 wxWindow *arg1 = (wxWindow *) 0 ;
36789 wxValidator *arg2 = 0 ;
36790 void *argp1 = 0 ;
36791 int res1 = 0 ;
36792 void *argp2 = 0 ;
36793 int res2 = 0 ;
36794 PyObject * obj0 = 0 ;
36795 PyObject * obj1 = 0 ;
36796 char * kwnames[] = {
36797 (char *) "self",(char *) "validator", NULL
36798 };
36799
36800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
36801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36802 if (!SWIG_IsOK(res1)) {
36803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
36804 }
36805 arg1 = reinterpret_cast< wxWindow * >(argp1);
36806 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
36807 if (!SWIG_IsOK(res2)) {
36808 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
36809 }
36810 if (!argp2) {
36811 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
36812 }
36813 arg2 = reinterpret_cast< wxValidator * >(argp2);
36814 {
36815 PyThreadState* __tstate = wxPyBeginAllowThreads();
36816 (arg1)->SetValidator((wxValidator const &)*arg2);
36817 wxPyEndAllowThreads(__tstate);
36818 if (PyErr_Occurred()) SWIG_fail;
36819 }
36820 resultobj = SWIG_Py_Void();
36821 return resultobj;
36822 fail:
36823 return NULL;
36824 }
36825
36826
36827 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36828 PyObject *resultobj = 0;
36829 wxWindow *arg1 = (wxWindow *) 0 ;
36830 wxValidator *result = 0 ;
36831 void *argp1 = 0 ;
36832 int res1 = 0 ;
36833 PyObject *swig_obj[1] ;
36834
36835 if (!args) SWIG_fail;
36836 swig_obj[0] = args;
36837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36838 if (!SWIG_IsOK(res1)) {
36839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
36840 }
36841 arg1 = reinterpret_cast< wxWindow * >(argp1);
36842 {
36843 PyThreadState* __tstate = wxPyBeginAllowThreads();
36844 result = (wxValidator *)(arg1)->GetValidator();
36845 wxPyEndAllowThreads(__tstate);
36846 if (PyErr_Occurred()) SWIG_fail;
36847 }
36848 {
36849 resultobj = wxPyMake_wxObject(result, (bool)0);
36850 }
36851 return resultobj;
36852 fail:
36853 return NULL;
36854 }
36855
36856
36857 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36858 PyObject *resultobj = 0;
36859 wxWindow *arg1 = (wxWindow *) 0 ;
36860 bool result;
36861 void *argp1 = 0 ;
36862 int res1 = 0 ;
36863 PyObject *swig_obj[1] ;
36864
36865 if (!args) SWIG_fail;
36866 swig_obj[0] = args;
36867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36868 if (!SWIG_IsOK(res1)) {
36869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
36870 }
36871 arg1 = reinterpret_cast< wxWindow * >(argp1);
36872 {
36873 PyThreadState* __tstate = wxPyBeginAllowThreads();
36874 result = (bool)(arg1)->Validate();
36875 wxPyEndAllowThreads(__tstate);
36876 if (PyErr_Occurred()) SWIG_fail;
36877 }
36878 {
36879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36880 }
36881 return resultobj;
36882 fail:
36883 return NULL;
36884 }
36885
36886
36887 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36888 PyObject *resultobj = 0;
36889 wxWindow *arg1 = (wxWindow *) 0 ;
36890 bool result;
36891 void *argp1 = 0 ;
36892 int res1 = 0 ;
36893 PyObject *swig_obj[1] ;
36894
36895 if (!args) SWIG_fail;
36896 swig_obj[0] = args;
36897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36898 if (!SWIG_IsOK(res1)) {
36899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36900 }
36901 arg1 = reinterpret_cast< wxWindow * >(argp1);
36902 {
36903 PyThreadState* __tstate = wxPyBeginAllowThreads();
36904 result = (bool)(arg1)->TransferDataToWindow();
36905 wxPyEndAllowThreads(__tstate);
36906 if (PyErr_Occurred()) SWIG_fail;
36907 }
36908 {
36909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36910 }
36911 return resultobj;
36912 fail:
36913 return NULL;
36914 }
36915
36916
36917 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36918 PyObject *resultobj = 0;
36919 wxWindow *arg1 = (wxWindow *) 0 ;
36920 bool result;
36921 void *argp1 = 0 ;
36922 int res1 = 0 ;
36923 PyObject *swig_obj[1] ;
36924
36925 if (!args) SWIG_fail;
36926 swig_obj[0] = args;
36927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36928 if (!SWIG_IsOK(res1)) {
36929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36930 }
36931 arg1 = reinterpret_cast< wxWindow * >(argp1);
36932 {
36933 PyThreadState* __tstate = wxPyBeginAllowThreads();
36934 result = (bool)(arg1)->TransferDataFromWindow();
36935 wxPyEndAllowThreads(__tstate);
36936 if (PyErr_Occurred()) SWIG_fail;
36937 }
36938 {
36939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36940 }
36941 return resultobj;
36942 fail:
36943 return NULL;
36944 }
36945
36946
36947 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36948 PyObject *resultobj = 0;
36949 wxWindow *arg1 = (wxWindow *) 0 ;
36950 void *argp1 = 0 ;
36951 int res1 = 0 ;
36952 PyObject *swig_obj[1] ;
36953
36954 if (!args) SWIG_fail;
36955 swig_obj[0] = args;
36956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36957 if (!SWIG_IsOK(res1)) {
36958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
36959 }
36960 arg1 = reinterpret_cast< wxWindow * >(argp1);
36961 {
36962 PyThreadState* __tstate = wxPyBeginAllowThreads();
36963 (arg1)->InitDialog();
36964 wxPyEndAllowThreads(__tstate);
36965 if (PyErr_Occurred()) SWIG_fail;
36966 }
36967 resultobj = SWIG_Py_Void();
36968 return resultobj;
36969 fail:
36970 return NULL;
36971 }
36972
36973
36974 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36975 PyObject *resultobj = 0;
36976 wxWindow *arg1 = (wxWindow *) 0 ;
36977 wxAcceleratorTable *arg2 = 0 ;
36978 void *argp1 = 0 ;
36979 int res1 = 0 ;
36980 void *argp2 = 0 ;
36981 int res2 = 0 ;
36982 PyObject * obj0 = 0 ;
36983 PyObject * obj1 = 0 ;
36984 char * kwnames[] = {
36985 (char *) "self",(char *) "accel", NULL
36986 };
36987
36988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
36989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36990 if (!SWIG_IsOK(res1)) {
36991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
36992 }
36993 arg1 = reinterpret_cast< wxWindow * >(argp1);
36994 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
36995 if (!SWIG_IsOK(res2)) {
36996 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
36997 }
36998 if (!argp2) {
36999 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37000 }
37001 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
37002 {
37003 PyThreadState* __tstate = wxPyBeginAllowThreads();
37004 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
37005 wxPyEndAllowThreads(__tstate);
37006 if (PyErr_Occurred()) SWIG_fail;
37007 }
37008 resultobj = SWIG_Py_Void();
37009 return resultobj;
37010 fail:
37011 return NULL;
37012 }
37013
37014
37015 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37016 PyObject *resultobj = 0;
37017 wxWindow *arg1 = (wxWindow *) 0 ;
37018 wxAcceleratorTable *result = 0 ;
37019 void *argp1 = 0 ;
37020 int res1 = 0 ;
37021 PyObject *swig_obj[1] ;
37022
37023 if (!args) SWIG_fail;
37024 swig_obj[0] = args;
37025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37026 if (!SWIG_IsOK(res1)) {
37027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37028 }
37029 arg1 = reinterpret_cast< wxWindow * >(argp1);
37030 {
37031 PyThreadState* __tstate = wxPyBeginAllowThreads();
37032 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
37033 wxPyEndAllowThreads(__tstate);
37034 if (PyErr_Occurred()) SWIG_fail;
37035 }
37036 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
37037 return resultobj;
37038 fail:
37039 return NULL;
37040 }
37041
37042
37043 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37044 PyObject *resultobj = 0;
37045 wxWindow *arg1 = (wxWindow *) 0 ;
37046 int arg2 ;
37047 int arg3 ;
37048 int arg4 ;
37049 bool result;
37050 void *argp1 = 0 ;
37051 int res1 = 0 ;
37052 int val2 ;
37053 int ecode2 = 0 ;
37054 int val3 ;
37055 int ecode3 = 0 ;
37056 int val4 ;
37057 int ecode4 = 0 ;
37058 PyObject * obj0 = 0 ;
37059 PyObject * obj1 = 0 ;
37060 PyObject * obj2 = 0 ;
37061 PyObject * obj3 = 0 ;
37062 char * kwnames[] = {
37063 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
37064 };
37065
37066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37068 if (!SWIG_IsOK(res1)) {
37069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37070 }
37071 arg1 = reinterpret_cast< wxWindow * >(argp1);
37072 ecode2 = SWIG_AsVal_int(obj1, &val2);
37073 if (!SWIG_IsOK(ecode2)) {
37074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
37075 }
37076 arg2 = static_cast< int >(val2);
37077 ecode3 = SWIG_AsVal_int(obj2, &val3);
37078 if (!SWIG_IsOK(ecode3)) {
37079 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
37080 }
37081 arg3 = static_cast< int >(val3);
37082 ecode4 = SWIG_AsVal_int(obj3, &val4);
37083 if (!SWIG_IsOK(ecode4)) {
37084 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
37085 }
37086 arg4 = static_cast< int >(val4);
37087 {
37088 PyThreadState* __tstate = wxPyBeginAllowThreads();
37089 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
37090 wxPyEndAllowThreads(__tstate);
37091 if (PyErr_Occurred()) SWIG_fail;
37092 }
37093 {
37094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37095 }
37096 return resultobj;
37097 fail:
37098 return NULL;
37099 }
37100
37101
37102 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37103 PyObject *resultobj = 0;
37104 wxWindow *arg1 = (wxWindow *) 0 ;
37105 int arg2 ;
37106 bool result;
37107 void *argp1 = 0 ;
37108 int res1 = 0 ;
37109 int val2 ;
37110 int ecode2 = 0 ;
37111 PyObject * obj0 = 0 ;
37112 PyObject * obj1 = 0 ;
37113 char * kwnames[] = {
37114 (char *) "self",(char *) "hotkeyId", NULL
37115 };
37116
37117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
37118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37119 if (!SWIG_IsOK(res1)) {
37120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37121 }
37122 arg1 = reinterpret_cast< wxWindow * >(argp1);
37123 ecode2 = SWIG_AsVal_int(obj1, &val2);
37124 if (!SWIG_IsOK(ecode2)) {
37125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
37126 }
37127 arg2 = static_cast< int >(val2);
37128 {
37129 PyThreadState* __tstate = wxPyBeginAllowThreads();
37130 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
37131 wxPyEndAllowThreads(__tstate);
37132 if (PyErr_Occurred()) SWIG_fail;
37133 }
37134 {
37135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37136 }
37137 return resultobj;
37138 fail:
37139 return NULL;
37140 }
37141
37142
37143 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37144 PyObject *resultobj = 0;
37145 wxWindow *arg1 = (wxWindow *) 0 ;
37146 wxPoint *arg2 = 0 ;
37147 wxPoint result;
37148 void *argp1 = 0 ;
37149 int res1 = 0 ;
37150 wxPoint temp2 ;
37151 PyObject * obj0 = 0 ;
37152 PyObject * obj1 = 0 ;
37153 char * kwnames[] = {
37154 (char *) "self",(char *) "pt", NULL
37155 };
37156
37157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37159 if (!SWIG_IsOK(res1)) {
37160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37161 }
37162 arg1 = reinterpret_cast< wxWindow * >(argp1);
37163 {
37164 arg2 = &temp2;
37165 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37166 }
37167 {
37168 PyThreadState* __tstate = wxPyBeginAllowThreads();
37169 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37170 wxPyEndAllowThreads(__tstate);
37171 if (PyErr_Occurred()) SWIG_fail;
37172 }
37173 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37174 return resultobj;
37175 fail:
37176 return NULL;
37177 }
37178
37179
37180 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37181 PyObject *resultobj = 0;
37182 wxWindow *arg1 = (wxWindow *) 0 ;
37183 wxSize *arg2 = 0 ;
37184 wxSize result;
37185 void *argp1 = 0 ;
37186 int res1 = 0 ;
37187 wxSize temp2 ;
37188 PyObject * obj0 = 0 ;
37189 PyObject * obj1 = 0 ;
37190 char * kwnames[] = {
37191 (char *) "self",(char *) "sz", NULL
37192 };
37193
37194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37196 if (!SWIG_IsOK(res1)) {
37197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37198 }
37199 arg1 = reinterpret_cast< wxWindow * >(argp1);
37200 {
37201 arg2 = &temp2;
37202 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37203 }
37204 {
37205 PyThreadState* __tstate = wxPyBeginAllowThreads();
37206 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37207 wxPyEndAllowThreads(__tstate);
37208 if (PyErr_Occurred()) SWIG_fail;
37209 }
37210 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37211 return resultobj;
37212 fail:
37213 return NULL;
37214 }
37215
37216
37217 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37218 PyObject *resultobj = 0;
37219 wxWindow *arg1 = (wxWindow *) 0 ;
37220 wxPoint *arg2 = 0 ;
37221 wxPoint result;
37222 void *argp1 = 0 ;
37223 int res1 = 0 ;
37224 wxPoint temp2 ;
37225 PyObject * obj0 = 0 ;
37226 PyObject * obj1 = 0 ;
37227 char * kwnames[] = {
37228 (char *) "self",(char *) "pt", NULL
37229 };
37230
37231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
37232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37233 if (!SWIG_IsOK(res1)) {
37234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
37235 }
37236 arg1 = reinterpret_cast< wxWindow * >(argp1);
37237 {
37238 arg2 = &temp2;
37239 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37240 }
37241 {
37242 PyThreadState* __tstate = wxPyBeginAllowThreads();
37243 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37244 wxPyEndAllowThreads(__tstate);
37245 if (PyErr_Occurred()) SWIG_fail;
37246 }
37247 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37248 return resultobj;
37249 fail:
37250 return NULL;
37251 }
37252
37253
37254 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37255 PyObject *resultobj = 0;
37256 wxWindow *arg1 = (wxWindow *) 0 ;
37257 wxSize *arg2 = 0 ;
37258 wxSize result;
37259 void *argp1 = 0 ;
37260 int res1 = 0 ;
37261 wxSize temp2 ;
37262 PyObject * obj0 = 0 ;
37263 PyObject * obj1 = 0 ;
37264 char * kwnames[] = {
37265 (char *) "self",(char *) "sz", NULL
37266 };
37267
37268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
37269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37270 if (!SWIG_IsOK(res1)) {
37271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
37272 }
37273 arg1 = reinterpret_cast< wxWindow * >(argp1);
37274 {
37275 arg2 = &temp2;
37276 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37277 }
37278 {
37279 PyThreadState* __tstate = wxPyBeginAllowThreads();
37280 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37281 wxPyEndAllowThreads(__tstate);
37282 if (PyErr_Occurred()) SWIG_fail;
37283 }
37284 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37285 return resultobj;
37286 fail:
37287 return NULL;
37288 }
37289
37290
37291 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37292 PyObject *resultobj = 0;
37293 wxWindow *arg1 = (wxWindow *) 0 ;
37294 wxPoint *arg2 = 0 ;
37295 wxPoint result;
37296 void *argp1 = 0 ;
37297 int res1 = 0 ;
37298 wxPoint temp2 ;
37299 PyObject * obj0 = 0 ;
37300 PyObject * obj1 = 0 ;
37301 char * kwnames[] = {
37302 (char *) "self",(char *) "pt", NULL
37303 };
37304
37305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37307 if (!SWIG_IsOK(res1)) {
37308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37309 }
37310 arg1 = reinterpret_cast< wxWindow * >(argp1);
37311 {
37312 arg2 = &temp2;
37313 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37314 }
37315 {
37316 PyThreadState* __tstate = wxPyBeginAllowThreads();
37317 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
37318 wxPyEndAllowThreads(__tstate);
37319 if (PyErr_Occurred()) SWIG_fail;
37320 }
37321 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37322 return resultobj;
37323 fail:
37324 return NULL;
37325 }
37326
37327
37328 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37329 PyObject *resultobj = 0;
37330 wxWindow *arg1 = (wxWindow *) 0 ;
37331 wxSize *arg2 = 0 ;
37332 wxSize result;
37333 void *argp1 = 0 ;
37334 int res1 = 0 ;
37335 wxSize temp2 ;
37336 PyObject * obj0 = 0 ;
37337 PyObject * obj1 = 0 ;
37338 char * kwnames[] = {
37339 (char *) "self",(char *) "sz", NULL
37340 };
37341
37342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37344 if (!SWIG_IsOK(res1)) {
37345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37346 }
37347 arg1 = reinterpret_cast< wxWindow * >(argp1);
37348 {
37349 arg2 = &temp2;
37350 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37351 }
37352 {
37353 PyThreadState* __tstate = wxPyBeginAllowThreads();
37354 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
37355 wxPyEndAllowThreads(__tstate);
37356 if (PyErr_Occurred()) SWIG_fail;
37357 }
37358 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37359 return resultobj;
37360 fail:
37361 return NULL;
37362 }
37363
37364
37365 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37366 PyObject *resultobj = 0;
37367 wxWindow *arg1 = (wxWindow *) 0 ;
37368 int arg2 ;
37369 int arg3 ;
37370 void *argp1 = 0 ;
37371 int res1 = 0 ;
37372 int val2 ;
37373 int ecode2 = 0 ;
37374 int val3 ;
37375 int ecode3 = 0 ;
37376 PyObject * obj0 = 0 ;
37377 PyObject * obj1 = 0 ;
37378 PyObject * obj2 = 0 ;
37379 char * kwnames[] = {
37380 (char *) "self",(char *) "x",(char *) "y", NULL
37381 };
37382
37383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37385 if (!SWIG_IsOK(res1)) {
37386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
37387 }
37388 arg1 = reinterpret_cast< wxWindow * >(argp1);
37389 ecode2 = SWIG_AsVal_int(obj1, &val2);
37390 if (!SWIG_IsOK(ecode2)) {
37391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
37392 }
37393 arg2 = static_cast< int >(val2);
37394 ecode3 = SWIG_AsVal_int(obj2, &val3);
37395 if (!SWIG_IsOK(ecode3)) {
37396 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
37397 }
37398 arg3 = static_cast< int >(val3);
37399 {
37400 PyThreadState* __tstate = wxPyBeginAllowThreads();
37401 (arg1)->WarpPointer(arg2,arg3);
37402 wxPyEndAllowThreads(__tstate);
37403 if (PyErr_Occurred()) SWIG_fail;
37404 }
37405 resultobj = SWIG_Py_Void();
37406 return resultobj;
37407 fail:
37408 return NULL;
37409 }
37410
37411
37412 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37413 PyObject *resultobj = 0;
37414 wxWindow *arg1 = (wxWindow *) 0 ;
37415 void *argp1 = 0 ;
37416 int res1 = 0 ;
37417 PyObject *swig_obj[1] ;
37418
37419 if (!args) SWIG_fail;
37420 swig_obj[0] = args;
37421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37422 if (!SWIG_IsOK(res1)) {
37423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37424 }
37425 arg1 = reinterpret_cast< wxWindow * >(argp1);
37426 {
37427 PyThreadState* __tstate = wxPyBeginAllowThreads();
37428 (arg1)->CaptureMouse();
37429 wxPyEndAllowThreads(__tstate);
37430 if (PyErr_Occurred()) SWIG_fail;
37431 }
37432 resultobj = SWIG_Py_Void();
37433 return resultobj;
37434 fail:
37435 return NULL;
37436 }
37437
37438
37439 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37440 PyObject *resultobj = 0;
37441 wxWindow *arg1 = (wxWindow *) 0 ;
37442 void *argp1 = 0 ;
37443 int res1 = 0 ;
37444 PyObject *swig_obj[1] ;
37445
37446 if (!args) SWIG_fail;
37447 swig_obj[0] = args;
37448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37449 if (!SWIG_IsOK(res1)) {
37450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37451 }
37452 arg1 = reinterpret_cast< wxWindow * >(argp1);
37453 {
37454 PyThreadState* __tstate = wxPyBeginAllowThreads();
37455 (arg1)->ReleaseMouse();
37456 wxPyEndAllowThreads(__tstate);
37457 if (PyErr_Occurred()) SWIG_fail;
37458 }
37459 resultobj = SWIG_Py_Void();
37460 return resultobj;
37461 fail:
37462 return NULL;
37463 }
37464
37465
37466 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37467 PyObject *resultobj = 0;
37468 wxWindow *result = 0 ;
37469
37470 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
37471 {
37472 if (!wxPyCheckForApp()) SWIG_fail;
37473 PyThreadState* __tstate = wxPyBeginAllowThreads();
37474 result = (wxWindow *)wxWindow::GetCapture();
37475 wxPyEndAllowThreads(__tstate);
37476 if (PyErr_Occurred()) SWIG_fail;
37477 }
37478 {
37479 resultobj = wxPyMake_wxObject(result, 0);
37480 }
37481 return resultobj;
37482 fail:
37483 return NULL;
37484 }
37485
37486
37487 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37488 PyObject *resultobj = 0;
37489 wxWindow *arg1 = (wxWindow *) 0 ;
37490 bool result;
37491 void *argp1 = 0 ;
37492 int res1 = 0 ;
37493 PyObject *swig_obj[1] ;
37494
37495 if (!args) SWIG_fail;
37496 swig_obj[0] = args;
37497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37498 if (!SWIG_IsOK(res1)) {
37499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
37500 }
37501 arg1 = reinterpret_cast< wxWindow * >(argp1);
37502 {
37503 PyThreadState* __tstate = wxPyBeginAllowThreads();
37504 result = (bool)((wxWindow const *)arg1)->HasCapture();
37505 wxPyEndAllowThreads(__tstate);
37506 if (PyErr_Occurred()) SWIG_fail;
37507 }
37508 {
37509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37510 }
37511 return resultobj;
37512 fail:
37513 return NULL;
37514 }
37515
37516
37517 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37518 PyObject *resultobj = 0;
37519 wxWindow *arg1 = (wxWindow *) 0 ;
37520 bool arg2 = (bool) true ;
37521 wxRect *arg3 = (wxRect *) NULL ;
37522 void *argp1 = 0 ;
37523 int res1 = 0 ;
37524 bool val2 ;
37525 int ecode2 = 0 ;
37526 void *argp3 = 0 ;
37527 int res3 = 0 ;
37528 PyObject * obj0 = 0 ;
37529 PyObject * obj1 = 0 ;
37530 PyObject * obj2 = 0 ;
37531 char * kwnames[] = {
37532 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
37533 };
37534
37535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37537 if (!SWIG_IsOK(res1)) {
37538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
37539 }
37540 arg1 = reinterpret_cast< wxWindow * >(argp1);
37541 if (obj1) {
37542 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37543 if (!SWIG_IsOK(ecode2)) {
37544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
37545 }
37546 arg2 = static_cast< bool >(val2);
37547 }
37548 if (obj2) {
37549 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
37550 if (!SWIG_IsOK(res3)) {
37551 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
37552 }
37553 arg3 = reinterpret_cast< wxRect * >(argp3);
37554 }
37555 {
37556 PyThreadState* __tstate = wxPyBeginAllowThreads();
37557 (arg1)->Refresh(arg2,(wxRect const *)arg3);
37558 wxPyEndAllowThreads(__tstate);
37559 if (PyErr_Occurred()) SWIG_fail;
37560 }
37561 resultobj = SWIG_Py_Void();
37562 return resultobj;
37563 fail:
37564 return NULL;
37565 }
37566
37567
37568 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37569 PyObject *resultobj = 0;
37570 wxWindow *arg1 = (wxWindow *) 0 ;
37571 wxRect *arg2 = 0 ;
37572 bool arg3 = (bool) true ;
37573 void *argp1 = 0 ;
37574 int res1 = 0 ;
37575 wxRect temp2 ;
37576 bool val3 ;
37577 int ecode3 = 0 ;
37578 PyObject * obj0 = 0 ;
37579 PyObject * obj1 = 0 ;
37580 PyObject * obj2 = 0 ;
37581 char * kwnames[] = {
37582 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
37583 };
37584
37585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37587 if (!SWIG_IsOK(res1)) {
37588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
37589 }
37590 arg1 = reinterpret_cast< wxWindow * >(argp1);
37591 {
37592 arg2 = &temp2;
37593 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
37594 }
37595 if (obj2) {
37596 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37597 if (!SWIG_IsOK(ecode3)) {
37598 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
37599 }
37600 arg3 = static_cast< bool >(val3);
37601 }
37602 {
37603 PyThreadState* __tstate = wxPyBeginAllowThreads();
37604 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
37605 wxPyEndAllowThreads(__tstate);
37606 if (PyErr_Occurred()) SWIG_fail;
37607 }
37608 resultobj = SWIG_Py_Void();
37609 return resultobj;
37610 fail:
37611 return NULL;
37612 }
37613
37614
37615 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37616 PyObject *resultobj = 0;
37617 wxWindow *arg1 = (wxWindow *) 0 ;
37618 void *argp1 = 0 ;
37619 int res1 = 0 ;
37620 PyObject *swig_obj[1] ;
37621
37622 if (!args) SWIG_fail;
37623 swig_obj[0] = args;
37624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37625 if (!SWIG_IsOK(res1)) {
37626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
37627 }
37628 arg1 = reinterpret_cast< wxWindow * >(argp1);
37629 {
37630 PyThreadState* __tstate = wxPyBeginAllowThreads();
37631 (arg1)->Update();
37632 wxPyEndAllowThreads(__tstate);
37633 if (PyErr_Occurred()) SWIG_fail;
37634 }
37635 resultobj = SWIG_Py_Void();
37636 return resultobj;
37637 fail:
37638 return NULL;
37639 }
37640
37641
37642 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37643 PyObject *resultobj = 0;
37644 wxWindow *arg1 = (wxWindow *) 0 ;
37645 void *argp1 = 0 ;
37646 int res1 = 0 ;
37647 PyObject *swig_obj[1] ;
37648
37649 if (!args) SWIG_fail;
37650 swig_obj[0] = args;
37651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37652 if (!SWIG_IsOK(res1)) {
37653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
37654 }
37655 arg1 = reinterpret_cast< wxWindow * >(argp1);
37656 {
37657 PyThreadState* __tstate = wxPyBeginAllowThreads();
37658 (arg1)->ClearBackground();
37659 wxPyEndAllowThreads(__tstate);
37660 if (PyErr_Occurred()) SWIG_fail;
37661 }
37662 resultobj = SWIG_Py_Void();
37663 return resultobj;
37664 fail:
37665 return NULL;
37666 }
37667
37668
37669 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37670 PyObject *resultobj = 0;
37671 wxWindow *arg1 = (wxWindow *) 0 ;
37672 void *argp1 = 0 ;
37673 int res1 = 0 ;
37674 PyObject *swig_obj[1] ;
37675
37676 if (!args) SWIG_fail;
37677 swig_obj[0] = args;
37678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37679 if (!SWIG_IsOK(res1)) {
37680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
37681 }
37682 arg1 = reinterpret_cast< wxWindow * >(argp1);
37683 {
37684 PyThreadState* __tstate = wxPyBeginAllowThreads();
37685 (arg1)->Freeze();
37686 wxPyEndAllowThreads(__tstate);
37687 if (PyErr_Occurred()) SWIG_fail;
37688 }
37689 resultobj = SWIG_Py_Void();
37690 return resultobj;
37691 fail:
37692 return NULL;
37693 }
37694
37695
37696 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37697 PyObject *resultobj = 0;
37698 wxWindow *arg1 = (wxWindow *) 0 ;
37699 bool result;
37700 void *argp1 = 0 ;
37701 int res1 = 0 ;
37702 PyObject *swig_obj[1] ;
37703
37704 if (!args) SWIG_fail;
37705 swig_obj[0] = args;
37706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37707 if (!SWIG_IsOK(res1)) {
37708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
37709 }
37710 arg1 = reinterpret_cast< wxWindow * >(argp1);
37711 {
37712 PyThreadState* __tstate = wxPyBeginAllowThreads();
37713 result = (bool)((wxWindow const *)arg1)->IsFrozen();
37714 wxPyEndAllowThreads(__tstate);
37715 if (PyErr_Occurred()) SWIG_fail;
37716 }
37717 {
37718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37719 }
37720 return resultobj;
37721 fail:
37722 return NULL;
37723 }
37724
37725
37726 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37727 PyObject *resultobj = 0;
37728 wxWindow *arg1 = (wxWindow *) 0 ;
37729 void *argp1 = 0 ;
37730 int res1 = 0 ;
37731 PyObject *swig_obj[1] ;
37732
37733 if (!args) SWIG_fail;
37734 swig_obj[0] = args;
37735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37736 if (!SWIG_IsOK(res1)) {
37737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
37738 }
37739 arg1 = reinterpret_cast< wxWindow * >(argp1);
37740 {
37741 PyThreadState* __tstate = wxPyBeginAllowThreads();
37742 (arg1)->Thaw();
37743 wxPyEndAllowThreads(__tstate);
37744 if (PyErr_Occurred()) SWIG_fail;
37745 }
37746 resultobj = SWIG_Py_Void();
37747 return resultobj;
37748 fail:
37749 return NULL;
37750 }
37751
37752
37753 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37754 PyObject *resultobj = 0;
37755 wxWindow *arg1 = (wxWindow *) 0 ;
37756 wxDC *arg2 = 0 ;
37757 void *argp1 = 0 ;
37758 int res1 = 0 ;
37759 void *argp2 = 0 ;
37760 int res2 = 0 ;
37761 PyObject * obj0 = 0 ;
37762 PyObject * obj1 = 0 ;
37763 char * kwnames[] = {
37764 (char *) "self",(char *) "dc", NULL
37765 };
37766
37767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
37768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37769 if (!SWIG_IsOK(res1)) {
37770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
37771 }
37772 arg1 = reinterpret_cast< wxWindow * >(argp1);
37773 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
37774 if (!SWIG_IsOK(res2)) {
37775 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
37776 }
37777 if (!argp2) {
37778 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
37779 }
37780 arg2 = reinterpret_cast< wxDC * >(argp2);
37781 {
37782 PyThreadState* __tstate = wxPyBeginAllowThreads();
37783 (arg1)->PrepareDC(*arg2);
37784 wxPyEndAllowThreads(__tstate);
37785 if (PyErr_Occurred()) SWIG_fail;
37786 }
37787 resultobj = SWIG_Py_Void();
37788 return resultobj;
37789 fail:
37790 return NULL;
37791 }
37792
37793
37794 SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37795 PyObject *resultobj = 0;
37796 wxWindow *arg1 = (wxWindow *) 0 ;
37797 bool result;
37798 void *argp1 = 0 ;
37799 int res1 = 0 ;
37800 PyObject *swig_obj[1] ;
37801
37802 if (!args) SWIG_fail;
37803 swig_obj[0] = args;
37804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37805 if (!SWIG_IsOK(res1)) {
37806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
37807 }
37808 arg1 = reinterpret_cast< wxWindow * >(argp1);
37809 {
37810 PyThreadState* __tstate = wxPyBeginAllowThreads();
37811 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
37812 wxPyEndAllowThreads(__tstate);
37813 if (PyErr_Occurred()) SWIG_fail;
37814 }
37815 {
37816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37817 }
37818 return resultobj;
37819 fail:
37820 return NULL;
37821 }
37822
37823
37824 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37825 PyObject *resultobj = 0;
37826 wxWindow *arg1 = (wxWindow *) 0 ;
37827 wxRegion *result = 0 ;
37828 void *argp1 = 0 ;
37829 int res1 = 0 ;
37830 PyObject *swig_obj[1] ;
37831
37832 if (!args) SWIG_fail;
37833 swig_obj[0] = args;
37834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37835 if (!SWIG_IsOK(res1)) {
37836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
37837 }
37838 arg1 = reinterpret_cast< wxWindow * >(argp1);
37839 {
37840 PyThreadState* __tstate = wxPyBeginAllowThreads();
37841 {
37842 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
37843 result = (wxRegion *) &_result_ref;
37844 }
37845 wxPyEndAllowThreads(__tstate);
37846 if (PyErr_Occurred()) SWIG_fail;
37847 }
37848 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
37849 return resultobj;
37850 fail:
37851 return NULL;
37852 }
37853
37854
37855 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37856 PyObject *resultobj = 0;
37857 wxWindow *arg1 = (wxWindow *) 0 ;
37858 wxRect result;
37859 void *argp1 = 0 ;
37860 int res1 = 0 ;
37861 PyObject *swig_obj[1] ;
37862
37863 if (!args) SWIG_fail;
37864 swig_obj[0] = args;
37865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37866 if (!SWIG_IsOK(res1)) {
37867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
37868 }
37869 arg1 = reinterpret_cast< wxWindow * >(argp1);
37870 {
37871 PyThreadState* __tstate = wxPyBeginAllowThreads();
37872 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
37873 wxPyEndAllowThreads(__tstate);
37874 if (PyErr_Occurred()) SWIG_fail;
37875 }
37876 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
37877 return resultobj;
37878 fail:
37879 return NULL;
37880 }
37881
37882
37883 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37884 PyObject *resultobj = 0;
37885 wxWindow *arg1 = (wxWindow *) 0 ;
37886 int arg2 ;
37887 int arg3 ;
37888 int arg4 = (int) 1 ;
37889 int arg5 = (int) 1 ;
37890 bool result;
37891 void *argp1 = 0 ;
37892 int res1 = 0 ;
37893 int val2 ;
37894 int ecode2 = 0 ;
37895 int val3 ;
37896 int ecode3 = 0 ;
37897 int val4 ;
37898 int ecode4 = 0 ;
37899 int val5 ;
37900 int ecode5 = 0 ;
37901 PyObject * obj0 = 0 ;
37902 PyObject * obj1 = 0 ;
37903 PyObject * obj2 = 0 ;
37904 PyObject * obj3 = 0 ;
37905 PyObject * obj4 = 0 ;
37906 char * kwnames[] = {
37907 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
37908 };
37909
37910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
37911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37912 if (!SWIG_IsOK(res1)) {
37913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
37914 }
37915 arg1 = reinterpret_cast< wxWindow * >(argp1);
37916 ecode2 = SWIG_AsVal_int(obj1, &val2);
37917 if (!SWIG_IsOK(ecode2)) {
37918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
37919 }
37920 arg2 = static_cast< int >(val2);
37921 ecode3 = SWIG_AsVal_int(obj2, &val3);
37922 if (!SWIG_IsOK(ecode3)) {
37923 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
37924 }
37925 arg3 = static_cast< int >(val3);
37926 if (obj3) {
37927 ecode4 = SWIG_AsVal_int(obj3, &val4);
37928 if (!SWIG_IsOK(ecode4)) {
37929 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
37930 }
37931 arg4 = static_cast< int >(val4);
37932 }
37933 if (obj4) {
37934 ecode5 = SWIG_AsVal_int(obj4, &val5);
37935 if (!SWIG_IsOK(ecode5)) {
37936 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
37937 }
37938 arg5 = static_cast< int >(val5);
37939 }
37940 {
37941 PyThreadState* __tstate = wxPyBeginAllowThreads();
37942 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
37943 wxPyEndAllowThreads(__tstate);
37944 if (PyErr_Occurred()) SWIG_fail;
37945 }
37946 {
37947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37948 }
37949 return resultobj;
37950 fail:
37951 return NULL;
37952 }
37953
37954
37955 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37956 PyObject *resultobj = 0;
37957 wxWindow *arg1 = (wxWindow *) 0 ;
37958 wxPoint *arg2 = 0 ;
37959 bool result;
37960 void *argp1 = 0 ;
37961 int res1 = 0 ;
37962 wxPoint temp2 ;
37963 PyObject * obj0 = 0 ;
37964 PyObject * obj1 = 0 ;
37965 char * kwnames[] = {
37966 (char *) "self",(char *) "pt", NULL
37967 };
37968
37969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
37970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37971 if (!SWIG_IsOK(res1)) {
37972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
37973 }
37974 arg1 = reinterpret_cast< wxWindow * >(argp1);
37975 {
37976 arg2 = &temp2;
37977 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37978 }
37979 {
37980 PyThreadState* __tstate = wxPyBeginAllowThreads();
37981 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
37982 wxPyEndAllowThreads(__tstate);
37983 if (PyErr_Occurred()) SWIG_fail;
37984 }
37985 {
37986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37987 }
37988 return resultobj;
37989 fail:
37990 return NULL;
37991 }
37992
37993
37994 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37995 PyObject *resultobj = 0;
37996 wxWindow *arg1 = (wxWindow *) 0 ;
37997 wxRect *arg2 = 0 ;
37998 bool result;
37999 void *argp1 = 0 ;
38000 int res1 = 0 ;
38001 wxRect temp2 ;
38002 PyObject * obj0 = 0 ;
38003 PyObject * obj1 = 0 ;
38004 char * kwnames[] = {
38005 (char *) "self",(char *) "rect", NULL
38006 };
38007
38008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
38009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38010 if (!SWIG_IsOK(res1)) {
38011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38012 }
38013 arg1 = reinterpret_cast< wxWindow * >(argp1);
38014 {
38015 arg2 = &temp2;
38016 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38017 }
38018 {
38019 PyThreadState* __tstate = wxPyBeginAllowThreads();
38020 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
38021 wxPyEndAllowThreads(__tstate);
38022 if (PyErr_Occurred()) SWIG_fail;
38023 }
38024 {
38025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38026 }
38027 return resultobj;
38028 fail:
38029 return NULL;
38030 }
38031
38032
38033 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38034 PyObject *resultobj = 0;
38035 wxWindow *arg1 = (wxWindow *) 0 ;
38036 SwigValueWrapper<wxVisualAttributes > result;
38037 void *argp1 = 0 ;
38038 int res1 = 0 ;
38039 PyObject *swig_obj[1] ;
38040
38041 if (!args) SWIG_fail;
38042 swig_obj[0] = args;
38043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38044 if (!SWIG_IsOK(res1)) {
38045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
38046 }
38047 arg1 = reinterpret_cast< wxWindow * >(argp1);
38048 {
38049 PyThreadState* __tstate = wxPyBeginAllowThreads();
38050 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
38051 wxPyEndAllowThreads(__tstate);
38052 if (PyErr_Occurred()) SWIG_fail;
38053 }
38054 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38055 return resultobj;
38056 fail:
38057 return NULL;
38058 }
38059
38060
38061 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38062 PyObject *resultobj = 0;
38063 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38064 SwigValueWrapper<wxVisualAttributes > result;
38065 int val1 ;
38066 int ecode1 = 0 ;
38067 PyObject * obj0 = 0 ;
38068 char * kwnames[] = {
38069 (char *) "variant", NULL
38070 };
38071
38072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
38073 if (obj0) {
38074 ecode1 = SWIG_AsVal_int(obj0, &val1);
38075 if (!SWIG_IsOK(ecode1)) {
38076 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
38077 }
38078 arg1 = static_cast< wxWindowVariant >(val1);
38079 }
38080 {
38081 if (!wxPyCheckForApp()) SWIG_fail;
38082 PyThreadState* __tstate = wxPyBeginAllowThreads();
38083 result = wxWindow::GetClassDefaultAttributes(arg1);
38084 wxPyEndAllowThreads(__tstate);
38085 if (PyErr_Occurred()) SWIG_fail;
38086 }
38087 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38088 return resultobj;
38089 fail:
38090 return NULL;
38091 }
38092
38093
38094 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38095 PyObject *resultobj = 0;
38096 wxWindow *arg1 = (wxWindow *) 0 ;
38097 wxColour *arg2 = 0 ;
38098 bool result;
38099 void *argp1 = 0 ;
38100 int res1 = 0 ;
38101 wxColour temp2 ;
38102 PyObject * obj0 = 0 ;
38103 PyObject * obj1 = 0 ;
38104 char * kwnames[] = {
38105 (char *) "self",(char *) "colour", NULL
38106 };
38107
38108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38110 if (!SWIG_IsOK(res1)) {
38111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38112 }
38113 arg1 = reinterpret_cast< wxWindow * >(argp1);
38114 {
38115 arg2 = &temp2;
38116 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38117 }
38118 {
38119 PyThreadState* __tstate = wxPyBeginAllowThreads();
38120 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
38121 wxPyEndAllowThreads(__tstate);
38122 if (PyErr_Occurred()) SWIG_fail;
38123 }
38124 {
38125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38126 }
38127 return resultobj;
38128 fail:
38129 return NULL;
38130 }
38131
38132
38133 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38134 PyObject *resultobj = 0;
38135 wxWindow *arg1 = (wxWindow *) 0 ;
38136 wxColour *arg2 = 0 ;
38137 void *argp1 = 0 ;
38138 int res1 = 0 ;
38139 wxColour temp2 ;
38140 PyObject * obj0 = 0 ;
38141 PyObject * obj1 = 0 ;
38142 char * kwnames[] = {
38143 (char *) "self",(char *) "colour", NULL
38144 };
38145
38146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38148 if (!SWIG_IsOK(res1)) {
38149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38150 }
38151 arg1 = reinterpret_cast< wxWindow * >(argp1);
38152 {
38153 arg2 = &temp2;
38154 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38155 }
38156 {
38157 PyThreadState* __tstate = wxPyBeginAllowThreads();
38158 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
38159 wxPyEndAllowThreads(__tstate);
38160 if (PyErr_Occurred()) SWIG_fail;
38161 }
38162 resultobj = SWIG_Py_Void();
38163 return resultobj;
38164 fail:
38165 return NULL;
38166 }
38167
38168
38169 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38170 PyObject *resultobj = 0;
38171 wxWindow *arg1 = (wxWindow *) 0 ;
38172 wxColour *arg2 = 0 ;
38173 bool result;
38174 void *argp1 = 0 ;
38175 int res1 = 0 ;
38176 wxColour temp2 ;
38177 PyObject * obj0 = 0 ;
38178 PyObject * obj1 = 0 ;
38179 char * kwnames[] = {
38180 (char *) "self",(char *) "colour", NULL
38181 };
38182
38183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38185 if (!SWIG_IsOK(res1)) {
38186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38187 }
38188 arg1 = reinterpret_cast< wxWindow * >(argp1);
38189 {
38190 arg2 = &temp2;
38191 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38192 }
38193 {
38194 PyThreadState* __tstate = wxPyBeginAllowThreads();
38195 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
38196 wxPyEndAllowThreads(__tstate);
38197 if (PyErr_Occurred()) SWIG_fail;
38198 }
38199 {
38200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38201 }
38202 return resultobj;
38203 fail:
38204 return NULL;
38205 }
38206
38207
38208 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38209 PyObject *resultobj = 0;
38210 wxWindow *arg1 = (wxWindow *) 0 ;
38211 wxColour *arg2 = 0 ;
38212 void *argp1 = 0 ;
38213 int res1 = 0 ;
38214 wxColour temp2 ;
38215 PyObject * obj0 = 0 ;
38216 PyObject * obj1 = 0 ;
38217 char * kwnames[] = {
38218 (char *) "self",(char *) "colour", NULL
38219 };
38220
38221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38223 if (!SWIG_IsOK(res1)) {
38224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38225 }
38226 arg1 = reinterpret_cast< wxWindow * >(argp1);
38227 {
38228 arg2 = &temp2;
38229 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38230 }
38231 {
38232 PyThreadState* __tstate = wxPyBeginAllowThreads();
38233 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
38234 wxPyEndAllowThreads(__tstate);
38235 if (PyErr_Occurred()) SWIG_fail;
38236 }
38237 resultobj = SWIG_Py_Void();
38238 return resultobj;
38239 fail:
38240 return NULL;
38241 }
38242
38243
38244 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38245 PyObject *resultobj = 0;
38246 wxWindow *arg1 = (wxWindow *) 0 ;
38247 wxColour result;
38248 void *argp1 = 0 ;
38249 int res1 = 0 ;
38250 PyObject *swig_obj[1] ;
38251
38252 if (!args) SWIG_fail;
38253 swig_obj[0] = args;
38254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38255 if (!SWIG_IsOK(res1)) {
38256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38257 }
38258 arg1 = reinterpret_cast< wxWindow * >(argp1);
38259 {
38260 PyThreadState* __tstate = wxPyBeginAllowThreads();
38261 result = ((wxWindow const *)arg1)->GetBackgroundColour();
38262 wxPyEndAllowThreads(__tstate);
38263 if (PyErr_Occurred()) SWIG_fail;
38264 }
38265 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38266 return resultobj;
38267 fail:
38268 return NULL;
38269 }
38270
38271
38272 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38273 PyObject *resultobj = 0;
38274 wxWindow *arg1 = (wxWindow *) 0 ;
38275 wxColour result;
38276 void *argp1 = 0 ;
38277 int res1 = 0 ;
38278 PyObject *swig_obj[1] ;
38279
38280 if (!args) SWIG_fail;
38281 swig_obj[0] = args;
38282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38283 if (!SWIG_IsOK(res1)) {
38284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38285 }
38286 arg1 = reinterpret_cast< wxWindow * >(argp1);
38287 {
38288 PyThreadState* __tstate = wxPyBeginAllowThreads();
38289 result = ((wxWindow const *)arg1)->GetForegroundColour();
38290 wxPyEndAllowThreads(__tstate);
38291 if (PyErr_Occurred()) SWIG_fail;
38292 }
38293 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38294 return resultobj;
38295 fail:
38296 return NULL;
38297 }
38298
38299
38300 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38301 PyObject *resultobj = 0;
38302 wxWindow *arg1 = (wxWindow *) 0 ;
38303 bool result;
38304 void *argp1 = 0 ;
38305 int res1 = 0 ;
38306 PyObject *swig_obj[1] ;
38307
38308 if (!args) SWIG_fail;
38309 swig_obj[0] = args;
38310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38311 if (!SWIG_IsOK(res1)) {
38312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38313 }
38314 arg1 = reinterpret_cast< wxWindow * >(argp1);
38315 {
38316 PyThreadState* __tstate = wxPyBeginAllowThreads();
38317 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
38318 wxPyEndAllowThreads(__tstate);
38319 if (PyErr_Occurred()) SWIG_fail;
38320 }
38321 {
38322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38323 }
38324 return resultobj;
38325 fail:
38326 return NULL;
38327 }
38328
38329
38330 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38331 PyObject *resultobj = 0;
38332 wxWindow *arg1 = (wxWindow *) 0 ;
38333 bool result;
38334 void *argp1 = 0 ;
38335 int res1 = 0 ;
38336 PyObject *swig_obj[1] ;
38337
38338 if (!args) SWIG_fail;
38339 swig_obj[0] = args;
38340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38341 if (!SWIG_IsOK(res1)) {
38342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
38343 }
38344 arg1 = reinterpret_cast< wxWindow * >(argp1);
38345 {
38346 PyThreadState* __tstate = wxPyBeginAllowThreads();
38347 result = (bool)((wxWindow const *)arg1)->UseBgCol();
38348 wxPyEndAllowThreads(__tstate);
38349 if (PyErr_Occurred()) SWIG_fail;
38350 }
38351 {
38352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38353 }
38354 return resultobj;
38355 fail:
38356 return NULL;
38357 }
38358
38359
38360 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38361 PyObject *resultobj = 0;
38362 wxWindow *arg1 = (wxWindow *) 0 ;
38363 wxBackgroundStyle arg2 ;
38364 bool result;
38365 void *argp1 = 0 ;
38366 int res1 = 0 ;
38367 int val2 ;
38368 int ecode2 = 0 ;
38369 PyObject * obj0 = 0 ;
38370 PyObject * obj1 = 0 ;
38371 char * kwnames[] = {
38372 (char *) "self",(char *) "style", NULL
38373 };
38374
38375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
38376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38377 if (!SWIG_IsOK(res1)) {
38378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
38379 }
38380 arg1 = reinterpret_cast< wxWindow * >(argp1);
38381 ecode2 = SWIG_AsVal_int(obj1, &val2);
38382 if (!SWIG_IsOK(ecode2)) {
38383 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
38384 }
38385 arg2 = static_cast< wxBackgroundStyle >(val2);
38386 {
38387 PyThreadState* __tstate = wxPyBeginAllowThreads();
38388 result = (bool)(arg1)->SetBackgroundStyle(arg2);
38389 wxPyEndAllowThreads(__tstate);
38390 if (PyErr_Occurred()) SWIG_fail;
38391 }
38392 {
38393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38394 }
38395 return resultobj;
38396 fail:
38397 return NULL;
38398 }
38399
38400
38401 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38402 PyObject *resultobj = 0;
38403 wxWindow *arg1 = (wxWindow *) 0 ;
38404 wxBackgroundStyle result;
38405 void *argp1 = 0 ;
38406 int res1 = 0 ;
38407 PyObject *swig_obj[1] ;
38408
38409 if (!args) SWIG_fail;
38410 swig_obj[0] = args;
38411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38412 if (!SWIG_IsOK(res1)) {
38413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
38414 }
38415 arg1 = reinterpret_cast< wxWindow * >(argp1);
38416 {
38417 PyThreadState* __tstate = wxPyBeginAllowThreads();
38418 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
38419 wxPyEndAllowThreads(__tstate);
38420 if (PyErr_Occurred()) SWIG_fail;
38421 }
38422 resultobj = SWIG_From_int(static_cast< int >(result));
38423 return resultobj;
38424 fail:
38425 return NULL;
38426 }
38427
38428
38429 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38430 PyObject *resultobj = 0;
38431 wxWindow *arg1 = (wxWindow *) 0 ;
38432 bool result;
38433 void *argp1 = 0 ;
38434 int res1 = 0 ;
38435 PyObject *swig_obj[1] ;
38436
38437 if (!args) SWIG_fail;
38438 swig_obj[0] = args;
38439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38440 if (!SWIG_IsOK(res1)) {
38441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
38442 }
38443 arg1 = reinterpret_cast< wxWindow * >(argp1);
38444 {
38445 PyThreadState* __tstate = wxPyBeginAllowThreads();
38446 result = (bool)(arg1)->HasTransparentBackground();
38447 wxPyEndAllowThreads(__tstate);
38448 if (PyErr_Occurred()) SWIG_fail;
38449 }
38450 {
38451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38452 }
38453 return resultobj;
38454 fail:
38455 return NULL;
38456 }
38457
38458
38459 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38460 PyObject *resultobj = 0;
38461 wxWindow *arg1 = (wxWindow *) 0 ;
38462 wxCursor *arg2 = 0 ;
38463 bool result;
38464 void *argp1 = 0 ;
38465 int res1 = 0 ;
38466 void *argp2 = 0 ;
38467 int res2 = 0 ;
38468 PyObject * obj0 = 0 ;
38469 PyObject * obj1 = 0 ;
38470 char * kwnames[] = {
38471 (char *) "self",(char *) "cursor", NULL
38472 };
38473
38474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
38475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38476 if (!SWIG_IsOK(res1)) {
38477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38478 }
38479 arg1 = reinterpret_cast< wxWindow * >(argp1);
38480 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
38481 if (!SWIG_IsOK(res2)) {
38482 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38483 }
38484 if (!argp2) {
38485 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38486 }
38487 arg2 = reinterpret_cast< wxCursor * >(argp2);
38488 {
38489 PyThreadState* __tstate = wxPyBeginAllowThreads();
38490 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
38491 wxPyEndAllowThreads(__tstate);
38492 if (PyErr_Occurred()) SWIG_fail;
38493 }
38494 {
38495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38496 }
38497 return resultobj;
38498 fail:
38499 return NULL;
38500 }
38501
38502
38503 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38504 PyObject *resultobj = 0;
38505 wxWindow *arg1 = (wxWindow *) 0 ;
38506 wxCursor result;
38507 void *argp1 = 0 ;
38508 int res1 = 0 ;
38509 PyObject *swig_obj[1] ;
38510
38511 if (!args) SWIG_fail;
38512 swig_obj[0] = args;
38513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38514 if (!SWIG_IsOK(res1)) {
38515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38516 }
38517 arg1 = reinterpret_cast< wxWindow * >(argp1);
38518 {
38519 PyThreadState* __tstate = wxPyBeginAllowThreads();
38520 result = (arg1)->GetCursor();
38521 wxPyEndAllowThreads(__tstate);
38522 if (PyErr_Occurred()) SWIG_fail;
38523 }
38524 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
38525 return resultobj;
38526 fail:
38527 return NULL;
38528 }
38529
38530
38531 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38532 PyObject *resultobj = 0;
38533 wxWindow *arg1 = (wxWindow *) 0 ;
38534 wxFont *arg2 = 0 ;
38535 bool result;
38536 void *argp1 = 0 ;
38537 int res1 = 0 ;
38538 void *argp2 = 0 ;
38539 int res2 = 0 ;
38540 PyObject * obj0 = 0 ;
38541 PyObject * obj1 = 0 ;
38542 char * kwnames[] = {
38543 (char *) "self",(char *) "font", NULL
38544 };
38545
38546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
38547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38548 if (!SWIG_IsOK(res1)) {
38549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38550 }
38551 arg1 = reinterpret_cast< wxWindow * >(argp1);
38552 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38553 if (!SWIG_IsOK(res2)) {
38554 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38555 }
38556 if (!argp2) {
38557 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38558 }
38559 arg2 = reinterpret_cast< wxFont * >(argp2);
38560 {
38561 PyThreadState* __tstate = wxPyBeginAllowThreads();
38562 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
38563 wxPyEndAllowThreads(__tstate);
38564 if (PyErr_Occurred()) SWIG_fail;
38565 }
38566 {
38567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38568 }
38569 return resultobj;
38570 fail:
38571 return NULL;
38572 }
38573
38574
38575 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38576 PyObject *resultobj = 0;
38577 wxWindow *arg1 = (wxWindow *) 0 ;
38578 wxFont *arg2 = 0 ;
38579 void *argp1 = 0 ;
38580 int res1 = 0 ;
38581 void *argp2 = 0 ;
38582 int res2 = 0 ;
38583 PyObject * obj0 = 0 ;
38584 PyObject * obj1 = 0 ;
38585 char * kwnames[] = {
38586 (char *) "self",(char *) "font", NULL
38587 };
38588
38589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
38590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38591 if (!SWIG_IsOK(res1)) {
38592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38593 }
38594 arg1 = reinterpret_cast< wxWindow * >(argp1);
38595 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38596 if (!SWIG_IsOK(res2)) {
38597 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38598 }
38599 if (!argp2) {
38600 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38601 }
38602 arg2 = reinterpret_cast< wxFont * >(argp2);
38603 {
38604 PyThreadState* __tstate = wxPyBeginAllowThreads();
38605 (arg1)->SetOwnFont((wxFont const &)*arg2);
38606 wxPyEndAllowThreads(__tstate);
38607 if (PyErr_Occurred()) SWIG_fail;
38608 }
38609 resultobj = SWIG_Py_Void();
38610 return resultobj;
38611 fail:
38612 return NULL;
38613 }
38614
38615
38616 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38617 PyObject *resultobj = 0;
38618 wxWindow *arg1 = (wxWindow *) 0 ;
38619 wxFont result;
38620 void *argp1 = 0 ;
38621 int res1 = 0 ;
38622 PyObject *swig_obj[1] ;
38623
38624 if (!args) SWIG_fail;
38625 swig_obj[0] = args;
38626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38627 if (!SWIG_IsOK(res1)) {
38628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38629 }
38630 arg1 = reinterpret_cast< wxWindow * >(argp1);
38631 {
38632 PyThreadState* __tstate = wxPyBeginAllowThreads();
38633 result = (arg1)->GetFont();
38634 wxPyEndAllowThreads(__tstate);
38635 if (PyErr_Occurred()) SWIG_fail;
38636 }
38637 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
38638 return resultobj;
38639 fail:
38640 return NULL;
38641 }
38642
38643
38644 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38645 PyObject *resultobj = 0;
38646 wxWindow *arg1 = (wxWindow *) 0 ;
38647 wxCaret *arg2 = (wxCaret *) 0 ;
38648 void *argp1 = 0 ;
38649 int res1 = 0 ;
38650 int res2 = 0 ;
38651 PyObject * obj0 = 0 ;
38652 PyObject * obj1 = 0 ;
38653 char * kwnames[] = {
38654 (char *) "self",(char *) "caret", NULL
38655 };
38656
38657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
38658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38659 if (!SWIG_IsOK(res1)) {
38660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
38661 }
38662 arg1 = reinterpret_cast< wxWindow * >(argp1);
38663 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
38664 if (!SWIG_IsOK(res2)) {
38665 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
38666 }
38667 {
38668 PyThreadState* __tstate = wxPyBeginAllowThreads();
38669 (arg1)->SetCaret(arg2);
38670 wxPyEndAllowThreads(__tstate);
38671 if (PyErr_Occurred()) SWIG_fail;
38672 }
38673 resultobj = SWIG_Py_Void();
38674 return resultobj;
38675 fail:
38676 return NULL;
38677 }
38678
38679
38680 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38681 PyObject *resultobj = 0;
38682 wxWindow *arg1 = (wxWindow *) 0 ;
38683 wxCaret *result = 0 ;
38684 void *argp1 = 0 ;
38685 int res1 = 0 ;
38686 PyObject *swig_obj[1] ;
38687
38688 if (!args) SWIG_fail;
38689 swig_obj[0] = args;
38690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38691 if (!SWIG_IsOK(res1)) {
38692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
38693 }
38694 arg1 = reinterpret_cast< wxWindow * >(argp1);
38695 {
38696 PyThreadState* __tstate = wxPyBeginAllowThreads();
38697 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
38698 wxPyEndAllowThreads(__tstate);
38699 if (PyErr_Occurred()) SWIG_fail;
38700 }
38701 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
38702 return resultobj;
38703 fail:
38704 return NULL;
38705 }
38706
38707
38708 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38709 PyObject *resultobj = 0;
38710 wxWindow *arg1 = (wxWindow *) 0 ;
38711 int result;
38712 void *argp1 = 0 ;
38713 int res1 = 0 ;
38714 PyObject *swig_obj[1] ;
38715
38716 if (!args) SWIG_fail;
38717 swig_obj[0] = args;
38718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38719 if (!SWIG_IsOK(res1)) {
38720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
38721 }
38722 arg1 = reinterpret_cast< wxWindow * >(argp1);
38723 {
38724 PyThreadState* __tstate = wxPyBeginAllowThreads();
38725 result = (int)((wxWindow const *)arg1)->GetCharHeight();
38726 wxPyEndAllowThreads(__tstate);
38727 if (PyErr_Occurred()) SWIG_fail;
38728 }
38729 resultobj = SWIG_From_int(static_cast< int >(result));
38730 return resultobj;
38731 fail:
38732 return NULL;
38733 }
38734
38735
38736 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38737 PyObject *resultobj = 0;
38738 wxWindow *arg1 = (wxWindow *) 0 ;
38739 int result;
38740 void *argp1 = 0 ;
38741 int res1 = 0 ;
38742 PyObject *swig_obj[1] ;
38743
38744 if (!args) SWIG_fail;
38745 swig_obj[0] = args;
38746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38747 if (!SWIG_IsOK(res1)) {
38748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
38749 }
38750 arg1 = reinterpret_cast< wxWindow * >(argp1);
38751 {
38752 PyThreadState* __tstate = wxPyBeginAllowThreads();
38753 result = (int)((wxWindow const *)arg1)->GetCharWidth();
38754 wxPyEndAllowThreads(__tstate);
38755 if (PyErr_Occurred()) SWIG_fail;
38756 }
38757 resultobj = SWIG_From_int(static_cast< int >(result));
38758 return resultobj;
38759 fail:
38760 return NULL;
38761 }
38762
38763
38764 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38765 PyObject *resultobj = 0;
38766 wxWindow *arg1 = (wxWindow *) 0 ;
38767 wxString *arg2 = 0 ;
38768 int *arg3 = (int *) 0 ;
38769 int *arg4 = (int *) 0 ;
38770 void *argp1 = 0 ;
38771 int res1 = 0 ;
38772 bool temp2 = false ;
38773 int temp3 ;
38774 int res3 = SWIG_TMPOBJ ;
38775 int temp4 ;
38776 int res4 = SWIG_TMPOBJ ;
38777 PyObject * obj0 = 0 ;
38778 PyObject * obj1 = 0 ;
38779 char * kwnames[] = {
38780 (char *) "self",(char *) "string", NULL
38781 };
38782
38783 arg3 = &temp3;
38784 arg4 = &temp4;
38785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
38786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38787 if (!SWIG_IsOK(res1)) {
38788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
38789 }
38790 arg1 = reinterpret_cast< wxWindow * >(argp1);
38791 {
38792 arg2 = wxString_in_helper(obj1);
38793 if (arg2 == NULL) SWIG_fail;
38794 temp2 = true;
38795 }
38796 {
38797 PyThreadState* __tstate = wxPyBeginAllowThreads();
38798 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
38799 wxPyEndAllowThreads(__tstate);
38800 if (PyErr_Occurred()) SWIG_fail;
38801 }
38802 resultobj = SWIG_Py_Void();
38803 if (SWIG_IsTmpObj(res3)) {
38804 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38805 } else {
38806 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38807 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38808 }
38809 if (SWIG_IsTmpObj(res4)) {
38810 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
38811 } else {
38812 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38813 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
38814 }
38815 {
38816 if (temp2)
38817 delete arg2;
38818 }
38819 return resultobj;
38820 fail:
38821 {
38822 if (temp2)
38823 delete arg2;
38824 }
38825 return NULL;
38826 }
38827
38828
38829 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38830 PyObject *resultobj = 0;
38831 wxWindow *arg1 = (wxWindow *) 0 ;
38832 wxString *arg2 = 0 ;
38833 int *arg3 = (int *) 0 ;
38834 int *arg4 = (int *) 0 ;
38835 int *arg5 = (int *) 0 ;
38836 int *arg6 = (int *) 0 ;
38837 wxFont *arg7 = (wxFont *) NULL ;
38838 void *argp1 = 0 ;
38839 int res1 = 0 ;
38840 bool temp2 = false ;
38841 int temp3 ;
38842 int res3 = SWIG_TMPOBJ ;
38843 int temp4 ;
38844 int res4 = SWIG_TMPOBJ ;
38845 int temp5 ;
38846 int res5 = SWIG_TMPOBJ ;
38847 int temp6 ;
38848 int res6 = SWIG_TMPOBJ ;
38849 void *argp7 = 0 ;
38850 int res7 = 0 ;
38851 PyObject * obj0 = 0 ;
38852 PyObject * obj1 = 0 ;
38853 PyObject * obj2 = 0 ;
38854 char * kwnames[] = {
38855 (char *) "self",(char *) "string",(char *) "font", NULL
38856 };
38857
38858 arg3 = &temp3;
38859 arg4 = &temp4;
38860 arg5 = &temp5;
38861 arg6 = &temp6;
38862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38864 if (!SWIG_IsOK(res1)) {
38865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
38866 }
38867 arg1 = reinterpret_cast< wxWindow * >(argp1);
38868 {
38869 arg2 = wxString_in_helper(obj1);
38870 if (arg2 == NULL) SWIG_fail;
38871 temp2 = true;
38872 }
38873 if (obj2) {
38874 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
38875 if (!SWIG_IsOK(res7)) {
38876 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
38877 }
38878 arg7 = reinterpret_cast< wxFont * >(argp7);
38879 }
38880 {
38881 PyThreadState* __tstate = wxPyBeginAllowThreads();
38882 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
38883 wxPyEndAllowThreads(__tstate);
38884 if (PyErr_Occurred()) SWIG_fail;
38885 }
38886 resultobj = SWIG_Py_Void();
38887 if (SWIG_IsTmpObj(res3)) {
38888 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38889 } else {
38890 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38891 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38892 }
38893 if (SWIG_IsTmpObj(res4)) {
38894 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
38895 } else {
38896 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38897 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
38898 }
38899 if (SWIG_IsTmpObj(res5)) {
38900 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
38901 } else {
38902 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38903 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
38904 }
38905 if (SWIG_IsTmpObj(res6)) {
38906 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
38907 } else {
38908 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38909 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
38910 }
38911 {
38912 if (temp2)
38913 delete arg2;
38914 }
38915 return resultobj;
38916 fail:
38917 {
38918 if (temp2)
38919 delete arg2;
38920 }
38921 return NULL;
38922 }
38923
38924
38925 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38926 PyObject *resultobj = 0;
38927 wxWindow *arg1 = (wxWindow *) 0 ;
38928 int *arg2 = (int *) 0 ;
38929 int *arg3 = (int *) 0 ;
38930 void *argp1 = 0 ;
38931 int res1 = 0 ;
38932 int temp2 ;
38933 int res2 = 0 ;
38934 int temp3 ;
38935 int res3 = 0 ;
38936 PyObject * obj0 = 0 ;
38937 PyObject * obj1 = 0 ;
38938 PyObject * obj2 = 0 ;
38939 char * kwnames[] = {
38940 (char *) "self",(char *) "x",(char *) "y", NULL
38941 };
38942
38943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38945 if (!SWIG_IsOK(res1)) {
38946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
38947 }
38948 arg1 = reinterpret_cast< wxWindow * >(argp1);
38949 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
38950 int val;
38951 int ecode = SWIG_AsVal_int(obj1, &val);
38952 if (!SWIG_IsOK(ecode)) {
38953 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
38954 }
38955 temp2 = static_cast< int >(val);
38956 arg2 = &temp2;
38957 res2 = SWIG_AddTmpMask(ecode);
38958 }
38959 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
38960 int val;
38961 int ecode = SWIG_AsVal_int(obj2, &val);
38962 if (!SWIG_IsOK(ecode)) {
38963 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
38964 }
38965 temp3 = static_cast< int >(val);
38966 arg3 = &temp3;
38967 res3 = SWIG_AddTmpMask(ecode);
38968 }
38969 {
38970 PyThreadState* __tstate = wxPyBeginAllowThreads();
38971 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
38972 wxPyEndAllowThreads(__tstate);
38973 if (PyErr_Occurred()) SWIG_fail;
38974 }
38975 resultobj = SWIG_Py_Void();
38976 if (SWIG_IsTmpObj(res2)) {
38977 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
38978 } else {
38979 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38980 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
38981 }
38982 if (SWIG_IsTmpObj(res3)) {
38983 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38984 } else {
38985 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38986 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38987 }
38988 return resultobj;
38989 fail:
38990 return NULL;
38991 }
38992
38993
38994 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38995 PyObject *resultobj = 0;
38996 wxWindow *arg1 = (wxWindow *) 0 ;
38997 int *arg2 = (int *) 0 ;
38998 int *arg3 = (int *) 0 ;
38999 void *argp1 = 0 ;
39000 int res1 = 0 ;
39001 int temp2 ;
39002 int res2 = 0 ;
39003 int temp3 ;
39004 int res3 = 0 ;
39005 PyObject * obj0 = 0 ;
39006 PyObject * obj1 = 0 ;
39007 PyObject * obj2 = 0 ;
39008 char * kwnames[] = {
39009 (char *) "self",(char *) "x",(char *) "y", NULL
39010 };
39011
39012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39014 if (!SWIG_IsOK(res1)) {
39015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39016 }
39017 arg1 = reinterpret_cast< wxWindow * >(argp1);
39018 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39019 int val;
39020 int ecode = SWIG_AsVal_int(obj1, &val);
39021 if (!SWIG_IsOK(ecode)) {
39022 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
39023 }
39024 temp2 = static_cast< int >(val);
39025 arg2 = &temp2;
39026 res2 = SWIG_AddTmpMask(ecode);
39027 }
39028 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39029 int val;
39030 int ecode = SWIG_AsVal_int(obj2, &val);
39031 if (!SWIG_IsOK(ecode)) {
39032 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
39033 }
39034 temp3 = static_cast< int >(val);
39035 arg3 = &temp3;
39036 res3 = SWIG_AddTmpMask(ecode);
39037 }
39038 {
39039 PyThreadState* __tstate = wxPyBeginAllowThreads();
39040 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
39041 wxPyEndAllowThreads(__tstate);
39042 if (PyErr_Occurred()) SWIG_fail;
39043 }
39044 resultobj = SWIG_Py_Void();
39045 if (SWIG_IsTmpObj(res2)) {
39046 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39047 } else {
39048 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39049 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39050 }
39051 if (SWIG_IsTmpObj(res3)) {
39052 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39053 } else {
39054 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39055 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39056 }
39057 return resultobj;
39058 fail:
39059 return NULL;
39060 }
39061
39062
39063 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39064 PyObject *resultobj = 0;
39065 wxWindow *arg1 = (wxWindow *) 0 ;
39066 wxPoint *arg2 = 0 ;
39067 wxPoint result;
39068 void *argp1 = 0 ;
39069 int res1 = 0 ;
39070 wxPoint temp2 ;
39071 PyObject * obj0 = 0 ;
39072 PyObject * obj1 = 0 ;
39073 char * kwnames[] = {
39074 (char *) "self",(char *) "pt", NULL
39075 };
39076
39077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
39078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39079 if (!SWIG_IsOK(res1)) {
39080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
39081 }
39082 arg1 = reinterpret_cast< wxWindow * >(argp1);
39083 {
39084 arg2 = &temp2;
39085 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39086 }
39087 {
39088 PyThreadState* __tstate = wxPyBeginAllowThreads();
39089 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
39090 wxPyEndAllowThreads(__tstate);
39091 if (PyErr_Occurred()) SWIG_fail;
39092 }
39093 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39094 return resultobj;
39095 fail:
39096 return NULL;
39097 }
39098
39099
39100 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39101 PyObject *resultobj = 0;
39102 wxWindow *arg1 = (wxWindow *) 0 ;
39103 wxPoint *arg2 = 0 ;
39104 wxPoint result;
39105 void *argp1 = 0 ;
39106 int res1 = 0 ;
39107 wxPoint temp2 ;
39108 PyObject * obj0 = 0 ;
39109 PyObject * obj1 = 0 ;
39110 char * kwnames[] = {
39111 (char *) "self",(char *) "pt", NULL
39112 };
39113
39114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
39115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39116 if (!SWIG_IsOK(res1)) {
39117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
39118 }
39119 arg1 = reinterpret_cast< wxWindow * >(argp1);
39120 {
39121 arg2 = &temp2;
39122 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39123 }
39124 {
39125 PyThreadState* __tstate = wxPyBeginAllowThreads();
39126 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
39127 wxPyEndAllowThreads(__tstate);
39128 if (PyErr_Occurred()) SWIG_fail;
39129 }
39130 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39131 return resultobj;
39132 fail:
39133 return NULL;
39134 }
39135
39136
39137 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39138 PyObject *resultobj = 0;
39139 wxWindow *arg1 = (wxWindow *) 0 ;
39140 int arg2 ;
39141 int arg3 ;
39142 wxHitTest result;
39143 void *argp1 = 0 ;
39144 int res1 = 0 ;
39145 int val2 ;
39146 int ecode2 = 0 ;
39147 int val3 ;
39148 int ecode3 = 0 ;
39149 PyObject * obj0 = 0 ;
39150 PyObject * obj1 = 0 ;
39151 PyObject * obj2 = 0 ;
39152 char * kwnames[] = {
39153 (char *) "self",(char *) "x",(char *) "y", NULL
39154 };
39155
39156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39158 if (!SWIG_IsOK(res1)) {
39159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39160 }
39161 arg1 = reinterpret_cast< wxWindow * >(argp1);
39162 ecode2 = SWIG_AsVal_int(obj1, &val2);
39163 if (!SWIG_IsOK(ecode2)) {
39164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
39165 }
39166 arg2 = static_cast< int >(val2);
39167 ecode3 = SWIG_AsVal_int(obj2, &val3);
39168 if (!SWIG_IsOK(ecode3)) {
39169 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
39170 }
39171 arg3 = static_cast< int >(val3);
39172 {
39173 PyThreadState* __tstate = wxPyBeginAllowThreads();
39174 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
39175 wxPyEndAllowThreads(__tstate);
39176 if (PyErr_Occurred()) SWIG_fail;
39177 }
39178 resultobj = SWIG_From_int(static_cast< int >(result));
39179 return resultobj;
39180 fail:
39181 return NULL;
39182 }
39183
39184
39185 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39186 PyObject *resultobj = 0;
39187 wxWindow *arg1 = (wxWindow *) 0 ;
39188 wxPoint *arg2 = 0 ;
39189 wxHitTest result;
39190 void *argp1 = 0 ;
39191 int res1 = 0 ;
39192 wxPoint temp2 ;
39193 PyObject * obj0 = 0 ;
39194 PyObject * obj1 = 0 ;
39195 char * kwnames[] = {
39196 (char *) "self",(char *) "pt", NULL
39197 };
39198
39199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
39200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39201 if (!SWIG_IsOK(res1)) {
39202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
39203 }
39204 arg1 = reinterpret_cast< wxWindow * >(argp1);
39205 {
39206 arg2 = &temp2;
39207 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39208 }
39209 {
39210 PyThreadState* __tstate = wxPyBeginAllowThreads();
39211 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
39212 wxPyEndAllowThreads(__tstate);
39213 if (PyErr_Occurred()) SWIG_fail;
39214 }
39215 resultobj = SWIG_From_int(static_cast< int >(result));
39216 return resultobj;
39217 fail:
39218 return NULL;
39219 }
39220
39221
39222 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39223 PyObject *resultobj = 0;
39224 wxWindow *arg1 = (wxWindow *) 0 ;
39225 long arg2 ;
39226 wxBorder result;
39227 void *argp1 = 0 ;
39228 int res1 = 0 ;
39229 long val2 ;
39230 int ecode2 = 0 ;
39231
39232 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
39233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39234 if (!SWIG_IsOK(res1)) {
39235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39236 }
39237 arg1 = reinterpret_cast< wxWindow * >(argp1);
39238 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
39239 if (!SWIG_IsOK(ecode2)) {
39240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
39241 }
39242 arg2 = static_cast< long >(val2);
39243 {
39244 PyThreadState* __tstate = wxPyBeginAllowThreads();
39245 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
39246 wxPyEndAllowThreads(__tstate);
39247 if (PyErr_Occurred()) SWIG_fail;
39248 }
39249 resultobj = SWIG_From_int(static_cast< int >(result));
39250 return resultobj;
39251 fail:
39252 return NULL;
39253 }
39254
39255
39256 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39257 PyObject *resultobj = 0;
39258 wxWindow *arg1 = (wxWindow *) 0 ;
39259 wxBorder result;
39260 void *argp1 = 0 ;
39261 int res1 = 0 ;
39262
39263 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
39264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39265 if (!SWIG_IsOK(res1)) {
39266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39267 }
39268 arg1 = reinterpret_cast< wxWindow * >(argp1);
39269 {
39270 PyThreadState* __tstate = wxPyBeginAllowThreads();
39271 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
39272 wxPyEndAllowThreads(__tstate);
39273 if (PyErr_Occurred()) SWIG_fail;
39274 }
39275 resultobj = SWIG_From_int(static_cast< int >(result));
39276 return resultobj;
39277 fail:
39278 return NULL;
39279 }
39280
39281
39282 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
39283 int argc;
39284 PyObject *argv[3];
39285
39286 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
39287 --argc;
39288 if (argc == 1) {
39289 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
39290 }
39291 if (argc == 2) {
39292 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
39293 }
39294
39295 fail:
39296 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
39297 return NULL;
39298 }
39299
39300
39301 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39302 PyObject *resultobj = 0;
39303 wxWindow *arg1 = (wxWindow *) 0 ;
39304 long arg2 = (long) wxUPDATE_UI_NONE ;
39305 void *argp1 = 0 ;
39306 int res1 = 0 ;
39307 long val2 ;
39308 int ecode2 = 0 ;
39309 PyObject * obj0 = 0 ;
39310 PyObject * obj1 = 0 ;
39311 char * kwnames[] = {
39312 (char *) "self",(char *) "flags", NULL
39313 };
39314
39315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
39316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39317 if (!SWIG_IsOK(res1)) {
39318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
39319 }
39320 arg1 = reinterpret_cast< wxWindow * >(argp1);
39321 if (obj1) {
39322 ecode2 = SWIG_AsVal_long(obj1, &val2);
39323 if (!SWIG_IsOK(ecode2)) {
39324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
39325 }
39326 arg2 = static_cast< long >(val2);
39327 }
39328 {
39329 PyThreadState* __tstate = wxPyBeginAllowThreads();
39330 (arg1)->UpdateWindowUI(arg2);
39331 wxPyEndAllowThreads(__tstate);
39332 if (PyErr_Occurred()) SWIG_fail;
39333 }
39334 resultobj = SWIG_Py_Void();
39335 return resultobj;
39336 fail:
39337 return NULL;
39338 }
39339
39340
39341 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39342 PyObject *resultobj = 0;
39343 wxWindow *arg1 = (wxWindow *) 0 ;
39344 wxMenu *arg2 = (wxMenu *) 0 ;
39345 int arg3 = (int) -1 ;
39346 int arg4 = (int) -1 ;
39347 bool result;
39348 void *argp1 = 0 ;
39349 int res1 = 0 ;
39350 void *argp2 = 0 ;
39351 int res2 = 0 ;
39352 int val3 ;
39353 int ecode3 = 0 ;
39354 int val4 ;
39355 int ecode4 = 0 ;
39356 PyObject * obj0 = 0 ;
39357 PyObject * obj1 = 0 ;
39358 PyObject * obj2 = 0 ;
39359 PyObject * obj3 = 0 ;
39360 char * kwnames[] = {
39361 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
39362 };
39363
39364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39366 if (!SWIG_IsOK(res1)) {
39367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
39368 }
39369 arg1 = reinterpret_cast< wxWindow * >(argp1);
39370 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39371 if (!SWIG_IsOK(res2)) {
39372 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
39373 }
39374 arg2 = reinterpret_cast< wxMenu * >(argp2);
39375 if (obj2) {
39376 ecode3 = SWIG_AsVal_int(obj2, &val3);
39377 if (!SWIG_IsOK(ecode3)) {
39378 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
39379 }
39380 arg3 = static_cast< int >(val3);
39381 }
39382 if (obj3) {
39383 ecode4 = SWIG_AsVal_int(obj3, &val4);
39384 if (!SWIG_IsOK(ecode4)) {
39385 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
39386 }
39387 arg4 = static_cast< int >(val4);
39388 }
39389 {
39390 PyThreadState* __tstate = wxPyBeginAllowThreads();
39391 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
39392 wxPyEndAllowThreads(__tstate);
39393 if (PyErr_Occurred()) SWIG_fail;
39394 }
39395 {
39396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39397 }
39398 return resultobj;
39399 fail:
39400 return NULL;
39401 }
39402
39403
39404 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39405 PyObject *resultobj = 0;
39406 wxWindow *arg1 = (wxWindow *) 0 ;
39407 wxMenu *arg2 = (wxMenu *) 0 ;
39408 wxPoint const &arg3_defvalue = wxDefaultPosition ;
39409 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
39410 bool result;
39411 void *argp1 = 0 ;
39412 int res1 = 0 ;
39413 void *argp2 = 0 ;
39414 int res2 = 0 ;
39415 wxPoint temp3 ;
39416 PyObject * obj0 = 0 ;
39417 PyObject * obj1 = 0 ;
39418 PyObject * obj2 = 0 ;
39419 char * kwnames[] = {
39420 (char *) "self",(char *) "menu",(char *) "pos", NULL
39421 };
39422
39423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39425 if (!SWIG_IsOK(res1)) {
39426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
39427 }
39428 arg1 = reinterpret_cast< wxWindow * >(argp1);
39429 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39430 if (!SWIG_IsOK(res2)) {
39431 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39432 }
39433 arg2 = reinterpret_cast< wxMenu * >(argp2);
39434 if (obj2) {
39435 {
39436 arg3 = &temp3;
39437 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
39438 }
39439 }
39440 {
39441 PyThreadState* __tstate = wxPyBeginAllowThreads();
39442 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
39443 wxPyEndAllowThreads(__tstate);
39444 if (PyErr_Occurred()) SWIG_fail;
39445 }
39446 {
39447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39448 }
39449 return resultobj;
39450 fail:
39451 return NULL;
39452 }
39453
39454
39455 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39456 PyObject *resultobj = 0;
39457 wxWindow *arg1 = (wxWindow *) 0 ;
39458 bool result;
39459 void *argp1 = 0 ;
39460 int res1 = 0 ;
39461 PyObject *swig_obj[1] ;
39462
39463 if (!args) SWIG_fail;
39464 swig_obj[0] = args;
39465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39466 if (!SWIG_IsOK(res1)) {
39467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
39468 }
39469 arg1 = reinterpret_cast< wxWindow * >(argp1);
39470 {
39471 PyThreadState* __tstate = wxPyBeginAllowThreads();
39472 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
39473 wxPyEndAllowThreads(__tstate);
39474 if (PyErr_Occurred()) SWIG_fail;
39475 }
39476 {
39477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39478 }
39479 return resultobj;
39480 fail:
39481 return NULL;
39482 }
39483
39484
39485 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39486 PyObject *resultobj = 0;
39487 wxWindow *arg1 = (wxWindow *) 0 ;
39488 long result;
39489 void *argp1 = 0 ;
39490 int res1 = 0 ;
39491 PyObject *swig_obj[1] ;
39492
39493 if (!args) SWIG_fail;
39494 swig_obj[0] = args;
39495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39496 if (!SWIG_IsOK(res1)) {
39497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39498 }
39499 arg1 = reinterpret_cast< wxWindow * >(argp1);
39500 {
39501 PyThreadState* __tstate = wxPyBeginAllowThreads();
39502 result = (long)wxWindow_GetHandle(arg1);
39503 wxPyEndAllowThreads(__tstate);
39504 if (PyErr_Occurred()) SWIG_fail;
39505 }
39506 resultobj = SWIG_From_long(static_cast< long >(result));
39507 return resultobj;
39508 fail:
39509 return NULL;
39510 }
39511
39512
39513 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39514 PyObject *resultobj = 0;
39515 wxWindow *arg1 = (wxWindow *) 0 ;
39516 long arg2 ;
39517 void *argp1 = 0 ;
39518 int res1 = 0 ;
39519 long val2 ;
39520 int ecode2 = 0 ;
39521 PyObject * obj0 = 0 ;
39522 PyObject * obj1 = 0 ;
39523 char * kwnames[] = {
39524 (char *) "self",(char *) "handle", NULL
39525 };
39526
39527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
39528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39529 if (!SWIG_IsOK(res1)) {
39530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39531 }
39532 arg1 = reinterpret_cast< wxWindow * >(argp1);
39533 ecode2 = SWIG_AsVal_long(obj1, &val2);
39534 if (!SWIG_IsOK(ecode2)) {
39535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
39536 }
39537 arg2 = static_cast< long >(val2);
39538 {
39539 PyThreadState* __tstate = wxPyBeginAllowThreads();
39540 wxWindow_AssociateHandle(arg1,arg2);
39541 wxPyEndAllowThreads(__tstate);
39542 if (PyErr_Occurred()) SWIG_fail;
39543 }
39544 resultobj = SWIG_Py_Void();
39545 return resultobj;
39546 fail:
39547 return NULL;
39548 }
39549
39550
39551 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39552 PyObject *resultobj = 0;
39553 wxWindow *arg1 = (wxWindow *) 0 ;
39554 void *argp1 = 0 ;
39555 int res1 = 0 ;
39556 PyObject *swig_obj[1] ;
39557
39558 if (!args) SWIG_fail;
39559 swig_obj[0] = args;
39560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39561 if (!SWIG_IsOK(res1)) {
39562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39563 }
39564 arg1 = reinterpret_cast< wxWindow * >(argp1);
39565 {
39566 PyThreadState* __tstate = wxPyBeginAllowThreads();
39567 (arg1)->DissociateHandle();
39568 wxPyEndAllowThreads(__tstate);
39569 if (PyErr_Occurred()) SWIG_fail;
39570 }
39571 resultobj = SWIG_Py_Void();
39572 return resultobj;
39573 fail:
39574 return NULL;
39575 }
39576
39577
39578 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39579 PyObject *resultobj = 0;
39580 wxWindow *arg1 = (wxWindow *) 0 ;
39581 int arg2 ;
39582 bool result;
39583 void *argp1 = 0 ;
39584 int res1 = 0 ;
39585 int val2 ;
39586 int ecode2 = 0 ;
39587 PyObject * obj0 = 0 ;
39588 PyObject * obj1 = 0 ;
39589 char * kwnames[] = {
39590 (char *) "self",(char *) "orient", NULL
39591 };
39592
39593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
39594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39595 if (!SWIG_IsOK(res1)) {
39596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
39597 }
39598 arg1 = reinterpret_cast< wxWindow * >(argp1);
39599 ecode2 = SWIG_AsVal_int(obj1, &val2);
39600 if (!SWIG_IsOK(ecode2)) {
39601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
39602 }
39603 arg2 = static_cast< int >(val2);
39604 {
39605 PyThreadState* __tstate = wxPyBeginAllowThreads();
39606 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
39607 wxPyEndAllowThreads(__tstate);
39608 if (PyErr_Occurred()) SWIG_fail;
39609 }
39610 {
39611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39612 }
39613 return resultobj;
39614 fail:
39615 return NULL;
39616 }
39617
39618
39619 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39620 PyObject *resultobj = 0;
39621 wxWindow *arg1 = (wxWindow *) 0 ;
39622 int arg2 ;
39623 int arg3 ;
39624 int arg4 ;
39625 int arg5 ;
39626 bool arg6 = (bool) true ;
39627 void *argp1 = 0 ;
39628 int res1 = 0 ;
39629 int val2 ;
39630 int ecode2 = 0 ;
39631 int val3 ;
39632 int ecode3 = 0 ;
39633 int val4 ;
39634 int ecode4 = 0 ;
39635 int val5 ;
39636 int ecode5 = 0 ;
39637 bool val6 ;
39638 int ecode6 = 0 ;
39639 PyObject * obj0 = 0 ;
39640 PyObject * obj1 = 0 ;
39641 PyObject * obj2 = 0 ;
39642 PyObject * obj3 = 0 ;
39643 PyObject * obj4 = 0 ;
39644 PyObject * obj5 = 0 ;
39645 char * kwnames[] = {
39646 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
39647 };
39648
39649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39651 if (!SWIG_IsOK(res1)) {
39652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
39653 }
39654 arg1 = reinterpret_cast< wxWindow * >(argp1);
39655 ecode2 = SWIG_AsVal_int(obj1, &val2);
39656 if (!SWIG_IsOK(ecode2)) {
39657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
39658 }
39659 arg2 = static_cast< int >(val2);
39660 ecode3 = SWIG_AsVal_int(obj2, &val3);
39661 if (!SWIG_IsOK(ecode3)) {
39662 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
39663 }
39664 arg3 = static_cast< int >(val3);
39665 ecode4 = SWIG_AsVal_int(obj3, &val4);
39666 if (!SWIG_IsOK(ecode4)) {
39667 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
39668 }
39669 arg4 = static_cast< int >(val4);
39670 ecode5 = SWIG_AsVal_int(obj4, &val5);
39671 if (!SWIG_IsOK(ecode5)) {
39672 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
39673 }
39674 arg5 = static_cast< int >(val5);
39675 if (obj5) {
39676 ecode6 = SWIG_AsVal_bool(obj5, &val6);
39677 if (!SWIG_IsOK(ecode6)) {
39678 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
39679 }
39680 arg6 = static_cast< bool >(val6);
39681 }
39682 {
39683 PyThreadState* __tstate = wxPyBeginAllowThreads();
39684 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
39685 wxPyEndAllowThreads(__tstate);
39686 if (PyErr_Occurred()) SWIG_fail;
39687 }
39688 resultobj = SWIG_Py_Void();
39689 return resultobj;
39690 fail:
39691 return NULL;
39692 }
39693
39694
39695 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39696 PyObject *resultobj = 0;
39697 wxWindow *arg1 = (wxWindow *) 0 ;
39698 int arg2 ;
39699 int arg3 ;
39700 bool arg4 = (bool) true ;
39701 void *argp1 = 0 ;
39702 int res1 = 0 ;
39703 int val2 ;
39704 int ecode2 = 0 ;
39705 int val3 ;
39706 int ecode3 = 0 ;
39707 bool val4 ;
39708 int ecode4 = 0 ;
39709 PyObject * obj0 = 0 ;
39710 PyObject * obj1 = 0 ;
39711 PyObject * obj2 = 0 ;
39712 PyObject * obj3 = 0 ;
39713 char * kwnames[] = {
39714 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
39715 };
39716
39717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39719 if (!SWIG_IsOK(res1)) {
39720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
39721 }
39722 arg1 = reinterpret_cast< wxWindow * >(argp1);
39723 ecode2 = SWIG_AsVal_int(obj1, &val2);
39724 if (!SWIG_IsOK(ecode2)) {
39725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
39726 }
39727 arg2 = static_cast< int >(val2);
39728 ecode3 = SWIG_AsVal_int(obj2, &val3);
39729 if (!SWIG_IsOK(ecode3)) {
39730 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
39731 }
39732 arg3 = static_cast< int >(val3);
39733 if (obj3) {
39734 ecode4 = SWIG_AsVal_bool(obj3, &val4);
39735 if (!SWIG_IsOK(ecode4)) {
39736 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
39737 }
39738 arg4 = static_cast< bool >(val4);
39739 }
39740 {
39741 PyThreadState* __tstate = wxPyBeginAllowThreads();
39742 (arg1)->SetScrollPos(arg2,arg3,arg4);
39743 wxPyEndAllowThreads(__tstate);
39744 if (PyErr_Occurred()) SWIG_fail;
39745 }
39746 resultobj = SWIG_Py_Void();
39747 return resultobj;
39748 fail:
39749 return NULL;
39750 }
39751
39752
39753 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39754 PyObject *resultobj = 0;
39755 wxWindow *arg1 = (wxWindow *) 0 ;
39756 int arg2 ;
39757 int result;
39758 void *argp1 = 0 ;
39759 int res1 = 0 ;
39760 int val2 ;
39761 int ecode2 = 0 ;
39762 PyObject * obj0 = 0 ;
39763 PyObject * obj1 = 0 ;
39764 char * kwnames[] = {
39765 (char *) "self",(char *) "orientation", NULL
39766 };
39767
39768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
39769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39770 if (!SWIG_IsOK(res1)) {
39771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
39772 }
39773 arg1 = reinterpret_cast< wxWindow * >(argp1);
39774 ecode2 = SWIG_AsVal_int(obj1, &val2);
39775 if (!SWIG_IsOK(ecode2)) {
39776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
39777 }
39778 arg2 = static_cast< int >(val2);
39779 {
39780 PyThreadState* __tstate = wxPyBeginAllowThreads();
39781 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
39782 wxPyEndAllowThreads(__tstate);
39783 if (PyErr_Occurred()) SWIG_fail;
39784 }
39785 resultobj = SWIG_From_int(static_cast< int >(result));
39786 return resultobj;
39787 fail:
39788 return NULL;
39789 }
39790
39791
39792 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39793 PyObject *resultobj = 0;
39794 wxWindow *arg1 = (wxWindow *) 0 ;
39795 int arg2 ;
39796 int result;
39797 void *argp1 = 0 ;
39798 int res1 = 0 ;
39799 int val2 ;
39800 int ecode2 = 0 ;
39801 PyObject * obj0 = 0 ;
39802 PyObject * obj1 = 0 ;
39803 char * kwnames[] = {
39804 (char *) "self",(char *) "orientation", NULL
39805 };
39806
39807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
39808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39809 if (!SWIG_IsOK(res1)) {
39810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
39811 }
39812 arg1 = reinterpret_cast< wxWindow * >(argp1);
39813 ecode2 = SWIG_AsVal_int(obj1, &val2);
39814 if (!SWIG_IsOK(ecode2)) {
39815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
39816 }
39817 arg2 = static_cast< int >(val2);
39818 {
39819 PyThreadState* __tstate = wxPyBeginAllowThreads();
39820 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
39821 wxPyEndAllowThreads(__tstate);
39822 if (PyErr_Occurred()) SWIG_fail;
39823 }
39824 resultobj = SWIG_From_int(static_cast< int >(result));
39825 return resultobj;
39826 fail:
39827 return NULL;
39828 }
39829
39830
39831 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39832 PyObject *resultobj = 0;
39833 wxWindow *arg1 = (wxWindow *) 0 ;
39834 int arg2 ;
39835 int result;
39836 void *argp1 = 0 ;
39837 int res1 = 0 ;
39838 int val2 ;
39839 int ecode2 = 0 ;
39840 PyObject * obj0 = 0 ;
39841 PyObject * obj1 = 0 ;
39842 char * kwnames[] = {
39843 (char *) "self",(char *) "orientation", NULL
39844 };
39845
39846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
39847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39848 if (!SWIG_IsOK(res1)) {
39849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
39850 }
39851 arg1 = reinterpret_cast< wxWindow * >(argp1);
39852 ecode2 = SWIG_AsVal_int(obj1, &val2);
39853 if (!SWIG_IsOK(ecode2)) {
39854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
39855 }
39856 arg2 = static_cast< int >(val2);
39857 {
39858 PyThreadState* __tstate = wxPyBeginAllowThreads();
39859 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
39860 wxPyEndAllowThreads(__tstate);
39861 if (PyErr_Occurred()) SWIG_fail;
39862 }
39863 resultobj = SWIG_From_int(static_cast< int >(result));
39864 return resultobj;
39865 fail:
39866 return NULL;
39867 }
39868
39869
39870 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39871 PyObject *resultobj = 0;
39872 wxWindow *arg1 = (wxWindow *) 0 ;
39873 int arg2 ;
39874 int arg3 ;
39875 wxRect *arg4 = (wxRect *) NULL ;
39876 void *argp1 = 0 ;
39877 int res1 = 0 ;
39878 int val2 ;
39879 int ecode2 = 0 ;
39880 int val3 ;
39881 int ecode3 = 0 ;
39882 void *argp4 = 0 ;
39883 int res4 = 0 ;
39884 PyObject * obj0 = 0 ;
39885 PyObject * obj1 = 0 ;
39886 PyObject * obj2 = 0 ;
39887 PyObject * obj3 = 0 ;
39888 char * kwnames[] = {
39889 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
39890 };
39891
39892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39894 if (!SWIG_IsOK(res1)) {
39895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
39896 }
39897 arg1 = reinterpret_cast< wxWindow * >(argp1);
39898 ecode2 = SWIG_AsVal_int(obj1, &val2);
39899 if (!SWIG_IsOK(ecode2)) {
39900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
39901 }
39902 arg2 = static_cast< int >(val2);
39903 ecode3 = SWIG_AsVal_int(obj2, &val3);
39904 if (!SWIG_IsOK(ecode3)) {
39905 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
39906 }
39907 arg3 = static_cast< int >(val3);
39908 if (obj3) {
39909 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
39910 if (!SWIG_IsOK(res4)) {
39911 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
39912 }
39913 arg4 = reinterpret_cast< wxRect * >(argp4);
39914 }
39915 {
39916 PyThreadState* __tstate = wxPyBeginAllowThreads();
39917 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
39918 wxPyEndAllowThreads(__tstate);
39919 if (PyErr_Occurred()) SWIG_fail;
39920 }
39921 resultobj = SWIG_Py_Void();
39922 return resultobj;
39923 fail:
39924 return NULL;
39925 }
39926
39927
39928 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39929 PyObject *resultobj = 0;
39930 wxWindow *arg1 = (wxWindow *) 0 ;
39931 int arg2 ;
39932 bool result;
39933 void *argp1 = 0 ;
39934 int res1 = 0 ;
39935 int val2 ;
39936 int ecode2 = 0 ;
39937 PyObject * obj0 = 0 ;
39938 PyObject * obj1 = 0 ;
39939 char * kwnames[] = {
39940 (char *) "self",(char *) "lines", NULL
39941 };
39942
39943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
39944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39945 if (!SWIG_IsOK(res1)) {
39946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
39947 }
39948 arg1 = reinterpret_cast< wxWindow * >(argp1);
39949 ecode2 = SWIG_AsVal_int(obj1, &val2);
39950 if (!SWIG_IsOK(ecode2)) {
39951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
39952 }
39953 arg2 = static_cast< int >(val2);
39954 {
39955 PyThreadState* __tstate = wxPyBeginAllowThreads();
39956 result = (bool)(arg1)->ScrollLines(arg2);
39957 wxPyEndAllowThreads(__tstate);
39958 if (PyErr_Occurred()) SWIG_fail;
39959 }
39960 {
39961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39962 }
39963 return resultobj;
39964 fail:
39965 return NULL;
39966 }
39967
39968
39969 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39970 PyObject *resultobj = 0;
39971 wxWindow *arg1 = (wxWindow *) 0 ;
39972 int arg2 ;
39973 bool result;
39974 void *argp1 = 0 ;
39975 int res1 = 0 ;
39976 int val2 ;
39977 int ecode2 = 0 ;
39978 PyObject * obj0 = 0 ;
39979 PyObject * obj1 = 0 ;
39980 char * kwnames[] = {
39981 (char *) "self",(char *) "pages", NULL
39982 };
39983
39984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
39985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39986 if (!SWIG_IsOK(res1)) {
39987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
39988 }
39989 arg1 = reinterpret_cast< wxWindow * >(argp1);
39990 ecode2 = SWIG_AsVal_int(obj1, &val2);
39991 if (!SWIG_IsOK(ecode2)) {
39992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
39993 }
39994 arg2 = static_cast< int >(val2);
39995 {
39996 PyThreadState* __tstate = wxPyBeginAllowThreads();
39997 result = (bool)(arg1)->ScrollPages(arg2);
39998 wxPyEndAllowThreads(__tstate);
39999 if (PyErr_Occurred()) SWIG_fail;
40000 }
40001 {
40002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40003 }
40004 return resultobj;
40005 fail:
40006 return NULL;
40007 }
40008
40009
40010 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40011 PyObject *resultobj = 0;
40012 wxWindow *arg1 = (wxWindow *) 0 ;
40013 bool result;
40014 void *argp1 = 0 ;
40015 int res1 = 0 ;
40016 PyObject *swig_obj[1] ;
40017
40018 if (!args) SWIG_fail;
40019 swig_obj[0] = args;
40020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40021 if (!SWIG_IsOK(res1)) {
40022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40023 }
40024 arg1 = reinterpret_cast< wxWindow * >(argp1);
40025 {
40026 PyThreadState* __tstate = wxPyBeginAllowThreads();
40027 result = (bool)(arg1)->LineUp();
40028 wxPyEndAllowThreads(__tstate);
40029 if (PyErr_Occurred()) SWIG_fail;
40030 }
40031 {
40032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40033 }
40034 return resultobj;
40035 fail:
40036 return NULL;
40037 }
40038
40039
40040 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40041 PyObject *resultobj = 0;
40042 wxWindow *arg1 = (wxWindow *) 0 ;
40043 bool result;
40044 void *argp1 = 0 ;
40045 int res1 = 0 ;
40046 PyObject *swig_obj[1] ;
40047
40048 if (!args) SWIG_fail;
40049 swig_obj[0] = args;
40050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40051 if (!SWIG_IsOK(res1)) {
40052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40053 }
40054 arg1 = reinterpret_cast< wxWindow * >(argp1);
40055 {
40056 PyThreadState* __tstate = wxPyBeginAllowThreads();
40057 result = (bool)(arg1)->LineDown();
40058 wxPyEndAllowThreads(__tstate);
40059 if (PyErr_Occurred()) SWIG_fail;
40060 }
40061 {
40062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40063 }
40064 return resultobj;
40065 fail:
40066 return NULL;
40067 }
40068
40069
40070 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40071 PyObject *resultobj = 0;
40072 wxWindow *arg1 = (wxWindow *) 0 ;
40073 bool result;
40074 void *argp1 = 0 ;
40075 int res1 = 0 ;
40076 PyObject *swig_obj[1] ;
40077
40078 if (!args) SWIG_fail;
40079 swig_obj[0] = args;
40080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40081 if (!SWIG_IsOK(res1)) {
40082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40083 }
40084 arg1 = reinterpret_cast< wxWindow * >(argp1);
40085 {
40086 PyThreadState* __tstate = wxPyBeginAllowThreads();
40087 result = (bool)(arg1)->PageUp();
40088 wxPyEndAllowThreads(__tstate);
40089 if (PyErr_Occurred()) SWIG_fail;
40090 }
40091 {
40092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40093 }
40094 return resultobj;
40095 fail:
40096 return NULL;
40097 }
40098
40099
40100 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40101 PyObject *resultobj = 0;
40102 wxWindow *arg1 = (wxWindow *) 0 ;
40103 bool result;
40104 void *argp1 = 0 ;
40105 int res1 = 0 ;
40106 PyObject *swig_obj[1] ;
40107
40108 if (!args) SWIG_fail;
40109 swig_obj[0] = args;
40110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40111 if (!SWIG_IsOK(res1)) {
40112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40113 }
40114 arg1 = reinterpret_cast< wxWindow * >(argp1);
40115 {
40116 PyThreadState* __tstate = wxPyBeginAllowThreads();
40117 result = (bool)(arg1)->PageDown();
40118 wxPyEndAllowThreads(__tstate);
40119 if (PyErr_Occurred()) SWIG_fail;
40120 }
40121 {
40122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40123 }
40124 return resultobj;
40125 fail:
40126 return NULL;
40127 }
40128
40129
40130 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40131 PyObject *resultobj = 0;
40132 wxWindow *arg1 = (wxWindow *) 0 ;
40133 wxString *arg2 = 0 ;
40134 void *argp1 = 0 ;
40135 int res1 = 0 ;
40136 bool temp2 = false ;
40137 PyObject * obj0 = 0 ;
40138 PyObject * obj1 = 0 ;
40139 char * kwnames[] = {
40140 (char *) "self",(char *) "text", NULL
40141 };
40142
40143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
40144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40145 if (!SWIG_IsOK(res1)) {
40146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
40147 }
40148 arg1 = reinterpret_cast< wxWindow * >(argp1);
40149 {
40150 arg2 = wxString_in_helper(obj1);
40151 if (arg2 == NULL) SWIG_fail;
40152 temp2 = true;
40153 }
40154 {
40155 PyThreadState* __tstate = wxPyBeginAllowThreads();
40156 (arg1)->SetHelpText((wxString const &)*arg2);
40157 wxPyEndAllowThreads(__tstate);
40158 if (PyErr_Occurred()) SWIG_fail;
40159 }
40160 resultobj = SWIG_Py_Void();
40161 {
40162 if (temp2)
40163 delete arg2;
40164 }
40165 return resultobj;
40166 fail:
40167 {
40168 if (temp2)
40169 delete arg2;
40170 }
40171 return NULL;
40172 }
40173
40174
40175 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40176 PyObject *resultobj = 0;
40177 wxWindow *arg1 = (wxWindow *) 0 ;
40178 wxString *arg2 = 0 ;
40179 void *argp1 = 0 ;
40180 int res1 = 0 ;
40181 bool temp2 = false ;
40182 PyObject * obj0 = 0 ;
40183 PyObject * obj1 = 0 ;
40184 char * kwnames[] = {
40185 (char *) "self",(char *) "text", NULL
40186 };
40187
40188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
40189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40190 if (!SWIG_IsOK(res1)) {
40191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
40192 }
40193 arg1 = reinterpret_cast< wxWindow * >(argp1);
40194 {
40195 arg2 = wxString_in_helper(obj1);
40196 if (arg2 == NULL) SWIG_fail;
40197 temp2 = true;
40198 }
40199 {
40200 PyThreadState* __tstate = wxPyBeginAllowThreads();
40201 (arg1)->SetHelpTextForId((wxString const &)*arg2);
40202 wxPyEndAllowThreads(__tstate);
40203 if (PyErr_Occurred()) SWIG_fail;
40204 }
40205 resultobj = SWIG_Py_Void();
40206 {
40207 if (temp2)
40208 delete arg2;
40209 }
40210 return resultobj;
40211 fail:
40212 {
40213 if (temp2)
40214 delete arg2;
40215 }
40216 return NULL;
40217 }
40218
40219
40220 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40221 PyObject *resultobj = 0;
40222 wxWindow *arg1 = (wxWindow *) 0 ;
40223 wxPoint *arg2 = 0 ;
40224 wxHelpEvent::Origin arg3 ;
40225 wxString result;
40226 void *argp1 = 0 ;
40227 int res1 = 0 ;
40228 wxPoint temp2 ;
40229 void *argp3 ;
40230 int res3 = 0 ;
40231 PyObject * obj0 = 0 ;
40232 PyObject * obj1 = 0 ;
40233 PyObject * obj2 = 0 ;
40234 char * kwnames[] = {
40235 (char *) "self",(char *) "pt",(char *) "origin", NULL
40236 };
40237
40238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40240 if (!SWIG_IsOK(res1)) {
40241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
40242 }
40243 arg1 = reinterpret_cast< wxWindow * >(argp1);
40244 {
40245 arg2 = &temp2;
40246 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40247 }
40248 {
40249 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
40250 if (!SWIG_IsOK(res3)) {
40251 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40252 }
40253 if (!argp3) {
40254 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40255 } else {
40256 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
40257 arg3 = *temp;
40258 if (SWIG_IsNewObj(res3)) delete temp;
40259 }
40260 }
40261 {
40262 PyThreadState* __tstate = wxPyBeginAllowThreads();
40263 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
40264 wxPyEndAllowThreads(__tstate);
40265 if (PyErr_Occurred()) SWIG_fail;
40266 }
40267 {
40268 #if wxUSE_UNICODE
40269 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40270 #else
40271 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40272 #endif
40273 }
40274 return resultobj;
40275 fail:
40276 return NULL;
40277 }
40278
40279
40280 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40281 PyObject *resultobj = 0;
40282 wxWindow *arg1 = (wxWindow *) 0 ;
40283 wxString result;
40284 void *argp1 = 0 ;
40285 int res1 = 0 ;
40286 PyObject *swig_obj[1] ;
40287
40288 if (!args) SWIG_fail;
40289 swig_obj[0] = args;
40290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40291 if (!SWIG_IsOK(res1)) {
40292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
40293 }
40294 arg1 = reinterpret_cast< wxWindow * >(argp1);
40295 {
40296 PyThreadState* __tstate = wxPyBeginAllowThreads();
40297 result = ((wxWindow const *)arg1)->GetHelpText();
40298 wxPyEndAllowThreads(__tstate);
40299 if (PyErr_Occurred()) SWIG_fail;
40300 }
40301 {
40302 #if wxUSE_UNICODE
40303 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40304 #else
40305 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40306 #endif
40307 }
40308 return resultobj;
40309 fail:
40310 return NULL;
40311 }
40312
40313
40314 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40315 PyObject *resultobj = 0;
40316 wxWindow *arg1 = (wxWindow *) 0 ;
40317 wxString *arg2 = 0 ;
40318 void *argp1 = 0 ;
40319 int res1 = 0 ;
40320 bool temp2 = false ;
40321 PyObject * obj0 = 0 ;
40322 PyObject * obj1 = 0 ;
40323 char * kwnames[] = {
40324 (char *) "self",(char *) "tip", NULL
40325 };
40326
40327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
40328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40329 if (!SWIG_IsOK(res1)) {
40330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
40331 }
40332 arg1 = reinterpret_cast< wxWindow * >(argp1);
40333 {
40334 arg2 = wxString_in_helper(obj1);
40335 if (arg2 == NULL) SWIG_fail;
40336 temp2 = true;
40337 }
40338 {
40339 PyThreadState* __tstate = wxPyBeginAllowThreads();
40340 (arg1)->SetToolTip((wxString const &)*arg2);
40341 wxPyEndAllowThreads(__tstate);
40342 if (PyErr_Occurred()) SWIG_fail;
40343 }
40344 resultobj = SWIG_Py_Void();
40345 {
40346 if (temp2)
40347 delete arg2;
40348 }
40349 return resultobj;
40350 fail:
40351 {
40352 if (temp2)
40353 delete arg2;
40354 }
40355 return NULL;
40356 }
40357
40358
40359 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40360 PyObject *resultobj = 0;
40361 wxWindow *arg1 = (wxWindow *) 0 ;
40362 wxToolTip *arg2 = (wxToolTip *) 0 ;
40363 void *argp1 = 0 ;
40364 int res1 = 0 ;
40365 int res2 = 0 ;
40366 PyObject * obj0 = 0 ;
40367 PyObject * obj1 = 0 ;
40368 char * kwnames[] = {
40369 (char *) "self",(char *) "tip", NULL
40370 };
40371
40372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
40373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40374 if (!SWIG_IsOK(res1)) {
40375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
40376 }
40377 arg1 = reinterpret_cast< wxWindow * >(argp1);
40378 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
40379 if (!SWIG_IsOK(res2)) {
40380 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
40381 }
40382 {
40383 PyThreadState* __tstate = wxPyBeginAllowThreads();
40384 (arg1)->SetToolTip(arg2);
40385 wxPyEndAllowThreads(__tstate);
40386 if (PyErr_Occurred()) SWIG_fail;
40387 }
40388 resultobj = SWIG_Py_Void();
40389 return resultobj;
40390 fail:
40391 return NULL;
40392 }
40393
40394
40395 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40396 PyObject *resultobj = 0;
40397 wxWindow *arg1 = (wxWindow *) 0 ;
40398 wxToolTip *result = 0 ;
40399 void *argp1 = 0 ;
40400 int res1 = 0 ;
40401 PyObject *swig_obj[1] ;
40402
40403 if (!args) SWIG_fail;
40404 swig_obj[0] = args;
40405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40406 if (!SWIG_IsOK(res1)) {
40407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
40408 }
40409 arg1 = reinterpret_cast< wxWindow * >(argp1);
40410 {
40411 PyThreadState* __tstate = wxPyBeginAllowThreads();
40412 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
40413 wxPyEndAllowThreads(__tstate);
40414 if (PyErr_Occurred()) SWIG_fail;
40415 }
40416 {
40417 resultobj = wxPyMake_wxObject(result, (bool)0);
40418 }
40419 return resultobj;
40420 fail:
40421 return NULL;
40422 }
40423
40424
40425 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40426 PyObject *resultobj = 0;
40427 wxWindow *arg1 = (wxWindow *) 0 ;
40428 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
40429 void *argp1 = 0 ;
40430 int res1 = 0 ;
40431 int res2 = 0 ;
40432 PyObject * obj0 = 0 ;
40433 PyObject * obj1 = 0 ;
40434 char * kwnames[] = {
40435 (char *) "self",(char *) "dropTarget", NULL
40436 };
40437
40438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
40439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40440 if (!SWIG_IsOK(res1)) {
40441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
40442 }
40443 arg1 = reinterpret_cast< wxWindow * >(argp1);
40444 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
40445 if (!SWIG_IsOK(res2)) {
40446 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
40447 }
40448 {
40449 PyThreadState* __tstate = wxPyBeginAllowThreads();
40450 (arg1)->SetDropTarget(arg2);
40451 wxPyEndAllowThreads(__tstate);
40452 if (PyErr_Occurred()) SWIG_fail;
40453 }
40454 resultobj = SWIG_Py_Void();
40455 return resultobj;
40456 fail:
40457 return NULL;
40458 }
40459
40460
40461 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40462 PyObject *resultobj = 0;
40463 wxWindow *arg1 = (wxWindow *) 0 ;
40464 wxPyDropTarget *result = 0 ;
40465 void *argp1 = 0 ;
40466 int res1 = 0 ;
40467 PyObject *swig_obj[1] ;
40468
40469 if (!args) SWIG_fail;
40470 swig_obj[0] = args;
40471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40472 if (!SWIG_IsOK(res1)) {
40473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
40474 }
40475 arg1 = reinterpret_cast< wxWindow * >(argp1);
40476 {
40477 PyThreadState* __tstate = wxPyBeginAllowThreads();
40478 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
40479 wxPyEndAllowThreads(__tstate);
40480 if (PyErr_Occurred()) SWIG_fail;
40481 }
40482 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
40483 return resultobj;
40484 fail:
40485 return NULL;
40486 }
40487
40488
40489 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40490 PyObject *resultobj = 0;
40491 wxWindow *arg1 = (wxWindow *) 0 ;
40492 bool arg2 ;
40493 void *argp1 = 0 ;
40494 int res1 = 0 ;
40495 bool val2 ;
40496 int ecode2 = 0 ;
40497 PyObject * obj0 = 0 ;
40498 PyObject * obj1 = 0 ;
40499 char * kwnames[] = {
40500 (char *) "self",(char *) "accept", NULL
40501 };
40502
40503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
40504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40505 if (!SWIG_IsOK(res1)) {
40506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
40507 }
40508 arg1 = reinterpret_cast< wxWindow * >(argp1);
40509 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40510 if (!SWIG_IsOK(ecode2)) {
40511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
40512 }
40513 arg2 = static_cast< bool >(val2);
40514 {
40515 PyThreadState* __tstate = wxPyBeginAllowThreads();
40516 wxWindow_DragAcceptFiles(arg1,arg2);
40517 wxPyEndAllowThreads(__tstate);
40518 if (PyErr_Occurred()) SWIG_fail;
40519 }
40520 resultobj = SWIG_Py_Void();
40521 return resultobj;
40522 fail:
40523 return NULL;
40524 }
40525
40526
40527 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40528 PyObject *resultobj = 0;
40529 wxWindow *arg1 = (wxWindow *) 0 ;
40530 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
40531 void *argp1 = 0 ;
40532 int res1 = 0 ;
40533 int res2 = 0 ;
40534 PyObject * obj0 = 0 ;
40535 PyObject * obj1 = 0 ;
40536 char * kwnames[] = {
40537 (char *) "self",(char *) "constraints", NULL
40538 };
40539
40540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
40541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40542 if (!SWIG_IsOK(res1)) {
40543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
40544 }
40545 arg1 = reinterpret_cast< wxWindow * >(argp1);
40546 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
40547 if (!SWIG_IsOK(res2)) {
40548 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
40549 }
40550 {
40551 PyThreadState* __tstate = wxPyBeginAllowThreads();
40552 (arg1)->SetConstraints(arg2);
40553 wxPyEndAllowThreads(__tstate);
40554 if (PyErr_Occurred()) SWIG_fail;
40555 }
40556 resultobj = SWIG_Py_Void();
40557 return resultobj;
40558 fail:
40559 return NULL;
40560 }
40561
40562
40563 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40564 PyObject *resultobj = 0;
40565 wxWindow *arg1 = (wxWindow *) 0 ;
40566 wxLayoutConstraints *result = 0 ;
40567 void *argp1 = 0 ;
40568 int res1 = 0 ;
40569 PyObject *swig_obj[1] ;
40570
40571 if (!args) SWIG_fail;
40572 swig_obj[0] = args;
40573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40574 if (!SWIG_IsOK(res1)) {
40575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
40576 }
40577 arg1 = reinterpret_cast< wxWindow * >(argp1);
40578 {
40579 PyThreadState* __tstate = wxPyBeginAllowThreads();
40580 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
40581 wxPyEndAllowThreads(__tstate);
40582 if (PyErr_Occurred()) SWIG_fail;
40583 }
40584 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
40585 return resultobj;
40586 fail:
40587 return NULL;
40588 }
40589
40590
40591 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40592 PyObject *resultobj = 0;
40593 wxWindow *arg1 = (wxWindow *) 0 ;
40594 bool arg2 ;
40595 void *argp1 = 0 ;
40596 int res1 = 0 ;
40597 bool val2 ;
40598 int ecode2 = 0 ;
40599 PyObject * obj0 = 0 ;
40600 PyObject * obj1 = 0 ;
40601 char * kwnames[] = {
40602 (char *) "self",(char *) "autoLayout", NULL
40603 };
40604
40605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
40606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40607 if (!SWIG_IsOK(res1)) {
40608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
40609 }
40610 arg1 = reinterpret_cast< wxWindow * >(argp1);
40611 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40612 if (!SWIG_IsOK(ecode2)) {
40613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
40614 }
40615 arg2 = static_cast< bool >(val2);
40616 {
40617 PyThreadState* __tstate = wxPyBeginAllowThreads();
40618 (arg1)->SetAutoLayout(arg2);
40619 wxPyEndAllowThreads(__tstate);
40620 if (PyErr_Occurred()) SWIG_fail;
40621 }
40622 resultobj = SWIG_Py_Void();
40623 return resultobj;
40624 fail:
40625 return NULL;
40626 }
40627
40628
40629 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40630 PyObject *resultobj = 0;
40631 wxWindow *arg1 = (wxWindow *) 0 ;
40632 bool result;
40633 void *argp1 = 0 ;
40634 int res1 = 0 ;
40635 PyObject *swig_obj[1] ;
40636
40637 if (!args) SWIG_fail;
40638 swig_obj[0] = args;
40639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40640 if (!SWIG_IsOK(res1)) {
40641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
40642 }
40643 arg1 = reinterpret_cast< wxWindow * >(argp1);
40644 {
40645 PyThreadState* __tstate = wxPyBeginAllowThreads();
40646 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
40647 wxPyEndAllowThreads(__tstate);
40648 if (PyErr_Occurred()) SWIG_fail;
40649 }
40650 {
40651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40652 }
40653 return resultobj;
40654 fail:
40655 return NULL;
40656 }
40657
40658
40659 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40660 PyObject *resultobj = 0;
40661 wxWindow *arg1 = (wxWindow *) 0 ;
40662 bool result;
40663 void *argp1 = 0 ;
40664 int res1 = 0 ;
40665 PyObject *swig_obj[1] ;
40666
40667 if (!args) SWIG_fail;
40668 swig_obj[0] = args;
40669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40670 if (!SWIG_IsOK(res1)) {
40671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
40672 }
40673 arg1 = reinterpret_cast< wxWindow * >(argp1);
40674 {
40675 PyThreadState* __tstate = wxPyBeginAllowThreads();
40676 result = (bool)(arg1)->Layout();
40677 wxPyEndAllowThreads(__tstate);
40678 if (PyErr_Occurred()) SWIG_fail;
40679 }
40680 {
40681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40682 }
40683 return resultobj;
40684 fail:
40685 return NULL;
40686 }
40687
40688
40689 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40690 PyObject *resultobj = 0;
40691 wxWindow *arg1 = (wxWindow *) 0 ;
40692 wxSizer *arg2 = (wxSizer *) 0 ;
40693 bool arg3 = (bool) true ;
40694 void *argp1 = 0 ;
40695 int res1 = 0 ;
40696 int res2 = 0 ;
40697 bool val3 ;
40698 int ecode3 = 0 ;
40699 PyObject * obj0 = 0 ;
40700 PyObject * obj1 = 0 ;
40701 PyObject * obj2 = 0 ;
40702 char * kwnames[] = {
40703 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40704 };
40705
40706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40708 if (!SWIG_IsOK(res1)) {
40709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40710 }
40711 arg1 = reinterpret_cast< wxWindow * >(argp1);
40712 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40713 if (!SWIG_IsOK(res2)) {
40714 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40715 }
40716 if (obj2) {
40717 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40718 if (!SWIG_IsOK(ecode3)) {
40719 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
40720 }
40721 arg3 = static_cast< bool >(val3);
40722 }
40723 {
40724 PyThreadState* __tstate = wxPyBeginAllowThreads();
40725 (arg1)->SetSizer(arg2,arg3);
40726 wxPyEndAllowThreads(__tstate);
40727 if (PyErr_Occurred()) SWIG_fail;
40728 }
40729 resultobj = SWIG_Py_Void();
40730 return resultobj;
40731 fail:
40732 return NULL;
40733 }
40734
40735
40736 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40737 PyObject *resultobj = 0;
40738 wxWindow *arg1 = (wxWindow *) 0 ;
40739 wxSizer *arg2 = (wxSizer *) 0 ;
40740 bool arg3 = (bool) true ;
40741 void *argp1 = 0 ;
40742 int res1 = 0 ;
40743 int res2 = 0 ;
40744 bool val3 ;
40745 int ecode3 = 0 ;
40746 PyObject * obj0 = 0 ;
40747 PyObject * obj1 = 0 ;
40748 PyObject * obj2 = 0 ;
40749 char * kwnames[] = {
40750 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40751 };
40752
40753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40755 if (!SWIG_IsOK(res1)) {
40756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
40757 }
40758 arg1 = reinterpret_cast< wxWindow * >(argp1);
40759 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40760 if (!SWIG_IsOK(res2)) {
40761 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
40762 }
40763 if (obj2) {
40764 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40765 if (!SWIG_IsOK(ecode3)) {
40766 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
40767 }
40768 arg3 = static_cast< bool >(val3);
40769 }
40770 {
40771 PyThreadState* __tstate = wxPyBeginAllowThreads();
40772 (arg1)->SetSizerAndFit(arg2,arg3);
40773 wxPyEndAllowThreads(__tstate);
40774 if (PyErr_Occurred()) SWIG_fail;
40775 }
40776 resultobj = SWIG_Py_Void();
40777 return resultobj;
40778 fail:
40779 return NULL;
40780 }
40781
40782
40783 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40784 PyObject *resultobj = 0;
40785 wxWindow *arg1 = (wxWindow *) 0 ;
40786 wxSizer *result = 0 ;
40787 void *argp1 = 0 ;
40788 int res1 = 0 ;
40789 PyObject *swig_obj[1] ;
40790
40791 if (!args) SWIG_fail;
40792 swig_obj[0] = args;
40793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40794 if (!SWIG_IsOK(res1)) {
40795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
40796 }
40797 arg1 = reinterpret_cast< wxWindow * >(argp1);
40798 {
40799 PyThreadState* __tstate = wxPyBeginAllowThreads();
40800 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
40801 wxPyEndAllowThreads(__tstate);
40802 if (PyErr_Occurred()) SWIG_fail;
40803 }
40804 {
40805 resultobj = wxPyMake_wxObject(result, (bool)0);
40806 }
40807 return resultobj;
40808 fail:
40809 return NULL;
40810 }
40811
40812
40813 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40814 PyObject *resultobj = 0;
40815 wxWindow *arg1 = (wxWindow *) 0 ;
40816 wxSizer *arg2 = (wxSizer *) 0 ;
40817 void *argp1 = 0 ;
40818 int res1 = 0 ;
40819 void *argp2 = 0 ;
40820 int res2 = 0 ;
40821 PyObject * obj0 = 0 ;
40822 PyObject * obj1 = 0 ;
40823 char * kwnames[] = {
40824 (char *) "self",(char *) "sizer", NULL
40825 };
40826
40827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
40828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40829 if (!SWIG_IsOK(res1)) {
40830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40831 }
40832 arg1 = reinterpret_cast< wxWindow * >(argp1);
40833 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
40834 if (!SWIG_IsOK(res2)) {
40835 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40836 }
40837 arg2 = reinterpret_cast< wxSizer * >(argp2);
40838 {
40839 PyThreadState* __tstate = wxPyBeginAllowThreads();
40840 (arg1)->SetContainingSizer(arg2);
40841 wxPyEndAllowThreads(__tstate);
40842 if (PyErr_Occurred()) SWIG_fail;
40843 }
40844 resultobj = SWIG_Py_Void();
40845 return resultobj;
40846 fail:
40847 return NULL;
40848 }
40849
40850
40851 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40852 PyObject *resultobj = 0;
40853 wxWindow *arg1 = (wxWindow *) 0 ;
40854 wxSizer *result = 0 ;
40855 void *argp1 = 0 ;
40856 int res1 = 0 ;
40857 PyObject *swig_obj[1] ;
40858
40859 if (!args) SWIG_fail;
40860 swig_obj[0] = args;
40861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40862 if (!SWIG_IsOK(res1)) {
40863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
40864 }
40865 arg1 = reinterpret_cast< wxWindow * >(argp1);
40866 {
40867 PyThreadState* __tstate = wxPyBeginAllowThreads();
40868 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
40869 wxPyEndAllowThreads(__tstate);
40870 if (PyErr_Occurred()) SWIG_fail;
40871 }
40872 {
40873 resultobj = wxPyMake_wxObject(result, (bool)0);
40874 }
40875 return resultobj;
40876 fail:
40877 return NULL;
40878 }
40879
40880
40881 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40882 PyObject *resultobj = 0;
40883 wxWindow *arg1 = (wxWindow *) 0 ;
40884 void *argp1 = 0 ;
40885 int res1 = 0 ;
40886 PyObject *swig_obj[1] ;
40887
40888 if (!args) SWIG_fail;
40889 swig_obj[0] = args;
40890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40891 if (!SWIG_IsOK(res1)) {
40892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
40893 }
40894 arg1 = reinterpret_cast< wxWindow * >(argp1);
40895 {
40896 PyThreadState* __tstate = wxPyBeginAllowThreads();
40897 (arg1)->InheritAttributes();
40898 wxPyEndAllowThreads(__tstate);
40899 if (PyErr_Occurred()) SWIG_fail;
40900 }
40901 resultobj = SWIG_Py_Void();
40902 return resultobj;
40903 fail:
40904 return NULL;
40905 }
40906
40907
40908 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40909 PyObject *resultobj = 0;
40910 wxWindow *arg1 = (wxWindow *) 0 ;
40911 bool result;
40912 void *argp1 = 0 ;
40913 int res1 = 0 ;
40914 PyObject *swig_obj[1] ;
40915
40916 if (!args) SWIG_fail;
40917 swig_obj[0] = args;
40918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40919 if (!SWIG_IsOK(res1)) {
40920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
40921 }
40922 arg1 = reinterpret_cast< wxWindow * >(argp1);
40923 {
40924 PyThreadState* __tstate = wxPyBeginAllowThreads();
40925 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
40926 wxPyEndAllowThreads(__tstate);
40927 if (PyErr_Occurred()) SWIG_fail;
40928 }
40929 {
40930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40931 }
40932 return resultobj;
40933 fail:
40934 return NULL;
40935 }
40936
40937
40938 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40939 PyObject *resultobj = 0;
40940 wxWindow *arg1 = (wxWindow *) 0 ;
40941 bool result;
40942 void *argp1 = 0 ;
40943 int res1 = 0 ;
40944 PyObject *swig_obj[1] ;
40945
40946 if (!args) SWIG_fail;
40947 swig_obj[0] = args;
40948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40949 if (!SWIG_IsOK(res1)) {
40950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
40951 }
40952 arg1 = reinterpret_cast< wxWindow * >(argp1);
40953 {
40954 PyThreadState* __tstate = wxPyBeginAllowThreads();
40955 result = (bool)(arg1)->CanSetTransparent();
40956 wxPyEndAllowThreads(__tstate);
40957 if (PyErr_Occurred()) SWIG_fail;
40958 }
40959 {
40960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40961 }
40962 return resultobj;
40963 fail:
40964 return NULL;
40965 }
40966
40967
40968 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40969 PyObject *resultobj = 0;
40970 wxWindow *arg1 = (wxWindow *) 0 ;
40971 byte arg2 ;
40972 bool result;
40973 void *argp1 = 0 ;
40974 int res1 = 0 ;
40975 unsigned char val2 ;
40976 int ecode2 = 0 ;
40977 PyObject * obj0 = 0 ;
40978 PyObject * obj1 = 0 ;
40979 char * kwnames[] = {
40980 (char *) "self",(char *) "alpha", NULL
40981 };
40982
40983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
40984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40985 if (!SWIG_IsOK(res1)) {
40986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
40987 }
40988 arg1 = reinterpret_cast< wxWindow * >(argp1);
40989 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
40990 if (!SWIG_IsOK(ecode2)) {
40991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
40992 }
40993 arg2 = static_cast< byte >(val2);
40994 {
40995 PyThreadState* __tstate = wxPyBeginAllowThreads();
40996 result = (bool)(arg1)->SetTransparent(arg2);
40997 wxPyEndAllowThreads(__tstate);
40998 if (PyErr_Occurred()) SWIG_fail;
40999 }
41000 {
41001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41002 }
41003 return resultobj;
41004 fail:
41005 return NULL;
41006 }
41007
41008
41009 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41010 PyObject *obj;
41011 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41012 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
41013 return SWIG_Py_Void();
41014 }
41015
41016 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41017 return SWIG_Python_InitShadowInstance(args);
41018 }
41019
41020 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41021 PyObject *resultobj = 0;
41022 long arg1 ;
41023 wxWindow *arg2 = (wxWindow *) NULL ;
41024 wxWindow *result = 0 ;
41025 long val1 ;
41026 int ecode1 = 0 ;
41027 void *argp2 = 0 ;
41028 int res2 = 0 ;
41029 PyObject * obj0 = 0 ;
41030 PyObject * obj1 = 0 ;
41031 char * kwnames[] = {
41032 (char *) "id",(char *) "parent", NULL
41033 };
41034
41035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
41036 ecode1 = SWIG_AsVal_long(obj0, &val1);
41037 if (!SWIG_IsOK(ecode1)) {
41038 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
41039 }
41040 arg1 = static_cast< long >(val1);
41041 if (obj1) {
41042 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41043 if (!SWIG_IsOK(res2)) {
41044 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
41045 }
41046 arg2 = reinterpret_cast< wxWindow * >(argp2);
41047 }
41048 {
41049 if (!wxPyCheckForApp()) SWIG_fail;
41050 PyThreadState* __tstate = wxPyBeginAllowThreads();
41051 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
41052 wxPyEndAllowThreads(__tstate);
41053 if (PyErr_Occurred()) SWIG_fail;
41054 }
41055 {
41056 resultobj = wxPyMake_wxObject(result, 0);
41057 }
41058 return resultobj;
41059 fail:
41060 return NULL;
41061 }
41062
41063
41064 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41065 PyObject *resultobj = 0;
41066 wxString *arg1 = 0 ;
41067 wxWindow *arg2 = (wxWindow *) NULL ;
41068 wxWindow *result = 0 ;
41069 bool temp1 = false ;
41070 void *argp2 = 0 ;
41071 int res2 = 0 ;
41072 PyObject * obj0 = 0 ;
41073 PyObject * obj1 = 0 ;
41074 char * kwnames[] = {
41075 (char *) "name",(char *) "parent", NULL
41076 };
41077
41078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
41079 {
41080 arg1 = wxString_in_helper(obj0);
41081 if (arg1 == NULL) SWIG_fail;
41082 temp1 = true;
41083 }
41084 if (obj1) {
41085 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41086 if (!SWIG_IsOK(res2)) {
41087 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
41088 }
41089 arg2 = reinterpret_cast< wxWindow * >(argp2);
41090 }
41091 {
41092 if (!wxPyCheckForApp()) SWIG_fail;
41093 PyThreadState* __tstate = wxPyBeginAllowThreads();
41094 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
41095 wxPyEndAllowThreads(__tstate);
41096 if (PyErr_Occurred()) SWIG_fail;
41097 }
41098 {
41099 resultobj = wxPyMake_wxObject(result, 0);
41100 }
41101 {
41102 if (temp1)
41103 delete arg1;
41104 }
41105 return resultobj;
41106 fail:
41107 {
41108 if (temp1)
41109 delete arg1;
41110 }
41111 return NULL;
41112 }
41113
41114
41115 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41116 PyObject *resultobj = 0;
41117 wxString *arg1 = 0 ;
41118 wxWindow *arg2 = (wxWindow *) NULL ;
41119 wxWindow *result = 0 ;
41120 bool temp1 = false ;
41121 void *argp2 = 0 ;
41122 int res2 = 0 ;
41123 PyObject * obj0 = 0 ;
41124 PyObject * obj1 = 0 ;
41125 char * kwnames[] = {
41126 (char *) "label",(char *) "parent", NULL
41127 };
41128
41129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41130 {
41131 arg1 = wxString_in_helper(obj0);
41132 if (arg1 == NULL) SWIG_fail;
41133 temp1 = true;
41134 }
41135 if (obj1) {
41136 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41137 if (!SWIG_IsOK(res2)) {
41138 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
41139 }
41140 arg2 = reinterpret_cast< wxWindow * >(argp2);
41141 }
41142 {
41143 if (!wxPyCheckForApp()) SWIG_fail;
41144 PyThreadState* __tstate = wxPyBeginAllowThreads();
41145 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
41146 wxPyEndAllowThreads(__tstate);
41147 if (PyErr_Occurred()) SWIG_fail;
41148 }
41149 {
41150 resultobj = wxPyMake_wxObject(result, 0);
41151 }
41152 {
41153 if (temp1)
41154 delete arg1;
41155 }
41156 return resultobj;
41157 fail:
41158 {
41159 if (temp1)
41160 delete arg1;
41161 }
41162 return NULL;
41163 }
41164
41165
41166 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41167 PyObject *resultobj = 0;
41168 wxWindow *arg1 = (wxWindow *) 0 ;
41169 unsigned long arg2 ;
41170 wxWindow *result = 0 ;
41171 void *argp1 = 0 ;
41172 int res1 = 0 ;
41173 unsigned long val2 ;
41174 int ecode2 = 0 ;
41175 PyObject * obj0 = 0 ;
41176 PyObject * obj1 = 0 ;
41177 char * kwnames[] = {
41178 (char *) "parent",(char *) "_hWnd", NULL
41179 };
41180
41181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
41182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41183 if (!SWIG_IsOK(res1)) {
41184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
41185 }
41186 arg1 = reinterpret_cast< wxWindow * >(argp1);
41187 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
41188 if (!SWIG_IsOK(ecode2)) {
41189 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
41190 }
41191 arg2 = static_cast< unsigned long >(val2);
41192 {
41193 PyThreadState* __tstate = wxPyBeginAllowThreads();
41194 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
41195 wxPyEndAllowThreads(__tstate);
41196 if (PyErr_Occurred()) SWIG_fail;
41197 }
41198 {
41199 resultobj = wxPyMake_wxObject(result, 0);
41200 }
41201 return resultobj;
41202 fail:
41203 return NULL;
41204 }
41205
41206
41207 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41208 PyObject *resultobj = 0;
41209 PyObject *result = 0 ;
41210
41211 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
41212 {
41213 PyThreadState* __tstate = wxPyBeginAllowThreads();
41214 result = (PyObject *)GetTopLevelWindows();
41215 wxPyEndAllowThreads(__tstate);
41216 if (PyErr_Occurred()) SWIG_fail;
41217 }
41218 resultobj = result;
41219 return resultobj;
41220 fail:
41221 return NULL;
41222 }
41223
41224
41225 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41226 PyObject *resultobj = 0;
41227 wxValidator *result = 0 ;
41228
41229 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
41230 {
41231 PyThreadState* __tstate = wxPyBeginAllowThreads();
41232 result = (wxValidator *)new wxValidator();
41233 wxPyEndAllowThreads(__tstate);
41234 if (PyErr_Occurred()) SWIG_fail;
41235 }
41236 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
41237 return resultobj;
41238 fail:
41239 return NULL;
41240 }
41241
41242
41243 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41244 PyObject *resultobj = 0;
41245 wxValidator *arg1 = (wxValidator *) 0 ;
41246 wxValidator *result = 0 ;
41247 void *argp1 = 0 ;
41248 int res1 = 0 ;
41249 PyObject *swig_obj[1] ;
41250
41251 if (!args) SWIG_fail;
41252 swig_obj[0] = args;
41253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41254 if (!SWIG_IsOK(res1)) {
41255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
41256 }
41257 arg1 = reinterpret_cast< wxValidator * >(argp1);
41258 {
41259 PyThreadState* __tstate = wxPyBeginAllowThreads();
41260 result = (wxValidator *)(arg1)->Clone();
41261 wxPyEndAllowThreads(__tstate);
41262 if (PyErr_Occurred()) SWIG_fail;
41263 }
41264 {
41265 resultobj = wxPyMake_wxObject(result, 0);
41266 }
41267 return resultobj;
41268 fail:
41269 return NULL;
41270 }
41271
41272
41273 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41274 PyObject *resultobj = 0;
41275 wxValidator *arg1 = (wxValidator *) 0 ;
41276 wxWindow *arg2 = (wxWindow *) 0 ;
41277 bool result;
41278 void *argp1 = 0 ;
41279 int res1 = 0 ;
41280 void *argp2 = 0 ;
41281 int res2 = 0 ;
41282 PyObject * obj0 = 0 ;
41283 PyObject * obj1 = 0 ;
41284 char * kwnames[] = {
41285 (char *) "self",(char *) "parent", NULL
41286 };
41287
41288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
41289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41290 if (!SWIG_IsOK(res1)) {
41291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
41292 }
41293 arg1 = reinterpret_cast< wxValidator * >(argp1);
41294 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41295 if (!SWIG_IsOK(res2)) {
41296 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
41297 }
41298 arg2 = reinterpret_cast< wxWindow * >(argp2);
41299 {
41300 PyThreadState* __tstate = wxPyBeginAllowThreads();
41301 result = (bool)(arg1)->Validate(arg2);
41302 wxPyEndAllowThreads(__tstate);
41303 if (PyErr_Occurred()) SWIG_fail;
41304 }
41305 {
41306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41307 }
41308 return resultobj;
41309 fail:
41310 return NULL;
41311 }
41312
41313
41314 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41315 PyObject *resultobj = 0;
41316 wxValidator *arg1 = (wxValidator *) 0 ;
41317 bool result;
41318 void *argp1 = 0 ;
41319 int res1 = 0 ;
41320 PyObject *swig_obj[1] ;
41321
41322 if (!args) SWIG_fail;
41323 swig_obj[0] = args;
41324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41325 if (!SWIG_IsOK(res1)) {
41326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41327 }
41328 arg1 = reinterpret_cast< wxValidator * >(argp1);
41329 {
41330 PyThreadState* __tstate = wxPyBeginAllowThreads();
41331 result = (bool)(arg1)->TransferToWindow();
41332 wxPyEndAllowThreads(__tstate);
41333 if (PyErr_Occurred()) SWIG_fail;
41334 }
41335 {
41336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41337 }
41338 return resultobj;
41339 fail:
41340 return NULL;
41341 }
41342
41343
41344 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41345 PyObject *resultobj = 0;
41346 wxValidator *arg1 = (wxValidator *) 0 ;
41347 bool result;
41348 void *argp1 = 0 ;
41349 int res1 = 0 ;
41350 PyObject *swig_obj[1] ;
41351
41352 if (!args) SWIG_fail;
41353 swig_obj[0] = args;
41354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41355 if (!SWIG_IsOK(res1)) {
41356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41357 }
41358 arg1 = reinterpret_cast< wxValidator * >(argp1);
41359 {
41360 PyThreadState* __tstate = wxPyBeginAllowThreads();
41361 result = (bool)(arg1)->TransferFromWindow();
41362 wxPyEndAllowThreads(__tstate);
41363 if (PyErr_Occurred()) SWIG_fail;
41364 }
41365 {
41366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41367 }
41368 return resultobj;
41369 fail:
41370 return NULL;
41371 }
41372
41373
41374 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41375 PyObject *resultobj = 0;
41376 wxValidator *arg1 = (wxValidator *) 0 ;
41377 wxWindow *result = 0 ;
41378 void *argp1 = 0 ;
41379 int res1 = 0 ;
41380 PyObject *swig_obj[1] ;
41381
41382 if (!args) SWIG_fail;
41383 swig_obj[0] = args;
41384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41385 if (!SWIG_IsOK(res1)) {
41386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41387 }
41388 arg1 = reinterpret_cast< wxValidator * >(argp1);
41389 {
41390 PyThreadState* __tstate = wxPyBeginAllowThreads();
41391 result = (wxWindow *)(arg1)->GetWindow();
41392 wxPyEndAllowThreads(__tstate);
41393 if (PyErr_Occurred()) SWIG_fail;
41394 }
41395 {
41396 resultobj = wxPyMake_wxObject(result, 0);
41397 }
41398 return resultobj;
41399 fail:
41400 return NULL;
41401 }
41402
41403
41404 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41405 PyObject *resultobj = 0;
41406 wxValidator *arg1 = (wxValidator *) 0 ;
41407 wxWindow *arg2 = (wxWindow *) 0 ;
41408 void *argp1 = 0 ;
41409 int res1 = 0 ;
41410 void *argp2 = 0 ;
41411 int res2 = 0 ;
41412 PyObject * obj0 = 0 ;
41413 PyObject * obj1 = 0 ;
41414 char * kwnames[] = {
41415 (char *) "self",(char *) "window", NULL
41416 };
41417
41418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41420 if (!SWIG_IsOK(res1)) {
41421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41422 }
41423 arg1 = reinterpret_cast< wxValidator * >(argp1);
41424 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41425 if (!SWIG_IsOK(res2)) {
41426 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41427 }
41428 arg2 = reinterpret_cast< wxWindow * >(argp2);
41429 {
41430 PyThreadState* __tstate = wxPyBeginAllowThreads();
41431 (arg1)->SetWindow(arg2);
41432 wxPyEndAllowThreads(__tstate);
41433 if (PyErr_Occurred()) SWIG_fail;
41434 }
41435 resultobj = SWIG_Py_Void();
41436 return resultobj;
41437 fail:
41438 return NULL;
41439 }
41440
41441
41442 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41443 PyObject *resultobj = 0;
41444 bool result;
41445
41446 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
41447 {
41448 PyThreadState* __tstate = wxPyBeginAllowThreads();
41449 result = (bool)wxValidator::IsSilent();
41450 wxPyEndAllowThreads(__tstate);
41451 if (PyErr_Occurred()) SWIG_fail;
41452 }
41453 {
41454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41455 }
41456 return resultobj;
41457 fail:
41458 return NULL;
41459 }
41460
41461
41462 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41463 PyObject *resultobj = 0;
41464 int arg1 = (int) true ;
41465 int val1 ;
41466 int ecode1 = 0 ;
41467 PyObject * obj0 = 0 ;
41468 char * kwnames[] = {
41469 (char *) "doIt", NULL
41470 };
41471
41472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
41473 if (obj0) {
41474 ecode1 = SWIG_AsVal_int(obj0, &val1);
41475 if (!SWIG_IsOK(ecode1)) {
41476 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
41477 }
41478 arg1 = static_cast< int >(val1);
41479 }
41480 {
41481 PyThreadState* __tstate = wxPyBeginAllowThreads();
41482 wxValidator::SetBellOnError(arg1);
41483 wxPyEndAllowThreads(__tstate);
41484 if (PyErr_Occurred()) SWIG_fail;
41485 }
41486 resultobj = SWIG_Py_Void();
41487 return resultobj;
41488 fail:
41489 return NULL;
41490 }
41491
41492
41493 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41494 PyObject *obj;
41495 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41496 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
41497 return SWIG_Py_Void();
41498 }
41499
41500 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41501 return SWIG_Python_InitShadowInstance(args);
41502 }
41503
41504 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41505 PyObject *resultobj = 0;
41506 wxPyValidator *result = 0 ;
41507
41508 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
41509 {
41510 PyThreadState* __tstate = wxPyBeginAllowThreads();
41511 result = (wxPyValidator *)new wxPyValidator();
41512 wxPyEndAllowThreads(__tstate);
41513 if (PyErr_Occurred()) SWIG_fail;
41514 }
41515 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
41516 return resultobj;
41517 fail:
41518 return NULL;
41519 }
41520
41521
41522 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41523 PyObject *resultobj = 0;
41524 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
41525 PyObject *arg2 = (PyObject *) 0 ;
41526 PyObject *arg3 = (PyObject *) 0 ;
41527 int arg4 = (int) true ;
41528 void *argp1 = 0 ;
41529 int res1 = 0 ;
41530 int val4 ;
41531 int ecode4 = 0 ;
41532 PyObject * obj0 = 0 ;
41533 PyObject * obj1 = 0 ;
41534 PyObject * obj2 = 0 ;
41535 PyObject * obj3 = 0 ;
41536 char * kwnames[] = {
41537 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
41538 };
41539
41540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
41542 if (!SWIG_IsOK(res1)) {
41543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
41544 }
41545 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
41546 arg2 = obj1;
41547 arg3 = obj2;
41548 if (obj3) {
41549 ecode4 = SWIG_AsVal_int(obj3, &val4);
41550 if (!SWIG_IsOK(ecode4)) {
41551 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
41552 }
41553 arg4 = static_cast< int >(val4);
41554 }
41555 {
41556 PyThreadState* __tstate = wxPyBeginAllowThreads();
41557 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
41558 wxPyEndAllowThreads(__tstate);
41559 if (PyErr_Occurred()) SWIG_fail;
41560 }
41561 resultobj = SWIG_Py_Void();
41562 return resultobj;
41563 fail:
41564 return NULL;
41565 }
41566
41567
41568 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41569 PyObject *obj;
41570 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41571 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
41572 return SWIG_Py_Void();
41573 }
41574
41575 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41576 return SWIG_Python_InitShadowInstance(args);
41577 }
41578
41579 SWIGINTERN int DefaultValidator_set(PyObject *) {
41580 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
41581 return 1;
41582 }
41583
41584
41585 SWIGINTERN PyObject *DefaultValidator_get(void) {
41586 PyObject *pyobj = 0;
41587
41588 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
41589 return pyobj;
41590 }
41591
41592
41593 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41594 PyObject *resultobj = 0;
41595 wxString const &arg1_defvalue = wxPyEmptyString ;
41596 wxString *arg1 = (wxString *) &arg1_defvalue ;
41597 long arg2 = (long) 0 ;
41598 wxMenu *result = 0 ;
41599 bool temp1 = false ;
41600 long val2 ;
41601 int ecode2 = 0 ;
41602 PyObject * obj0 = 0 ;
41603 PyObject * obj1 = 0 ;
41604 char * kwnames[] = {
41605 (char *) "title",(char *) "style", NULL
41606 };
41607
41608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
41609 if (obj0) {
41610 {
41611 arg1 = wxString_in_helper(obj0);
41612 if (arg1 == NULL) SWIG_fail;
41613 temp1 = true;
41614 }
41615 }
41616 if (obj1) {
41617 ecode2 = SWIG_AsVal_long(obj1, &val2);
41618 if (!SWIG_IsOK(ecode2)) {
41619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
41620 }
41621 arg2 = static_cast< long >(val2);
41622 }
41623 {
41624 if (!wxPyCheckForApp()) SWIG_fail;
41625 PyThreadState* __tstate = wxPyBeginAllowThreads();
41626 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
41627 wxPyEndAllowThreads(__tstate);
41628 if (PyErr_Occurred()) SWIG_fail;
41629 }
41630 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
41631 {
41632 if (temp1)
41633 delete arg1;
41634 }
41635 return resultobj;
41636 fail:
41637 {
41638 if (temp1)
41639 delete arg1;
41640 }
41641 return NULL;
41642 }
41643
41644
41645 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41646 PyObject *resultobj = 0;
41647 wxMenu *arg1 = (wxMenu *) 0 ;
41648 int arg2 ;
41649 wxString const &arg3_defvalue = wxPyEmptyString ;
41650 wxString *arg3 = (wxString *) &arg3_defvalue ;
41651 wxString const &arg4_defvalue = wxPyEmptyString ;
41652 wxString *arg4 = (wxString *) &arg4_defvalue ;
41653 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
41654 wxMenuItem *result = 0 ;
41655 void *argp1 = 0 ;
41656 int res1 = 0 ;
41657 int val2 ;
41658 int ecode2 = 0 ;
41659 bool temp3 = false ;
41660 bool temp4 = false ;
41661 int val5 ;
41662 int ecode5 = 0 ;
41663 PyObject * obj0 = 0 ;
41664 PyObject * obj1 = 0 ;
41665 PyObject * obj2 = 0 ;
41666 PyObject * obj3 = 0 ;
41667 PyObject * obj4 = 0 ;
41668 char * kwnames[] = {
41669 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
41670 };
41671
41672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
41673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41674 if (!SWIG_IsOK(res1)) {
41675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
41676 }
41677 arg1 = reinterpret_cast< wxMenu * >(argp1);
41678 ecode2 = SWIG_AsVal_int(obj1, &val2);
41679 if (!SWIG_IsOK(ecode2)) {
41680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
41681 }
41682 arg2 = static_cast< int >(val2);
41683 if (obj2) {
41684 {
41685 arg3 = wxString_in_helper(obj2);
41686 if (arg3 == NULL) SWIG_fail;
41687 temp3 = true;
41688 }
41689 }
41690 if (obj3) {
41691 {
41692 arg4 = wxString_in_helper(obj3);
41693 if (arg4 == NULL) SWIG_fail;
41694 temp4 = true;
41695 }
41696 }
41697 if (obj4) {
41698 ecode5 = SWIG_AsVal_int(obj4, &val5);
41699 if (!SWIG_IsOK(ecode5)) {
41700 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
41701 }
41702 arg5 = static_cast< wxItemKind >(val5);
41703 }
41704 {
41705 PyThreadState* __tstate = wxPyBeginAllowThreads();
41706 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
41707 wxPyEndAllowThreads(__tstate);
41708 if (PyErr_Occurred()) SWIG_fail;
41709 }
41710 {
41711 resultobj = wxPyMake_wxObject(result, (bool)0);
41712 }
41713 {
41714 if (temp3)
41715 delete arg3;
41716 }
41717 {
41718 if (temp4)
41719 delete arg4;
41720 }
41721 return resultobj;
41722 fail:
41723 {
41724 if (temp3)
41725 delete arg3;
41726 }
41727 {
41728 if (temp4)
41729 delete arg4;
41730 }
41731 return NULL;
41732 }
41733
41734
41735 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41736 PyObject *resultobj = 0;
41737 wxMenu *arg1 = (wxMenu *) 0 ;
41738 wxMenuItem *result = 0 ;
41739 void *argp1 = 0 ;
41740 int res1 = 0 ;
41741 PyObject *swig_obj[1] ;
41742
41743 if (!args) SWIG_fail;
41744 swig_obj[0] = args;
41745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41746 if (!SWIG_IsOK(res1)) {
41747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
41748 }
41749 arg1 = reinterpret_cast< wxMenu * >(argp1);
41750 {
41751 PyThreadState* __tstate = wxPyBeginAllowThreads();
41752 result = (wxMenuItem *)(arg1)->AppendSeparator();
41753 wxPyEndAllowThreads(__tstate);
41754 if (PyErr_Occurred()) SWIG_fail;
41755 }
41756 {
41757 resultobj = wxPyMake_wxObject(result, (bool)0);
41758 }
41759 return resultobj;
41760 fail:
41761 return NULL;
41762 }
41763
41764
41765 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41766 PyObject *resultobj = 0;
41767 wxMenu *arg1 = (wxMenu *) 0 ;
41768 int arg2 ;
41769 wxString *arg3 = 0 ;
41770 wxString const &arg4_defvalue = wxPyEmptyString ;
41771 wxString *arg4 = (wxString *) &arg4_defvalue ;
41772 wxMenuItem *result = 0 ;
41773 void *argp1 = 0 ;
41774 int res1 = 0 ;
41775 int val2 ;
41776 int ecode2 = 0 ;
41777 bool temp3 = false ;
41778 bool temp4 = false ;
41779 PyObject * obj0 = 0 ;
41780 PyObject * obj1 = 0 ;
41781 PyObject * obj2 = 0 ;
41782 PyObject * obj3 = 0 ;
41783 char * kwnames[] = {
41784 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
41785 };
41786
41787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41789 if (!SWIG_IsOK(res1)) {
41790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41791 }
41792 arg1 = reinterpret_cast< wxMenu * >(argp1);
41793 ecode2 = SWIG_AsVal_int(obj1, &val2);
41794 if (!SWIG_IsOK(ecode2)) {
41795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
41796 }
41797 arg2 = static_cast< int >(val2);
41798 {
41799 arg3 = wxString_in_helper(obj2);
41800 if (arg3 == NULL) SWIG_fail;
41801 temp3 = true;
41802 }
41803 if (obj3) {
41804 {
41805 arg4 = wxString_in_helper(obj3);
41806 if (arg4 == NULL) SWIG_fail;
41807 temp4 = true;
41808 }
41809 }
41810 {
41811 PyThreadState* __tstate = wxPyBeginAllowThreads();
41812 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
41813 wxPyEndAllowThreads(__tstate);
41814 if (PyErr_Occurred()) SWIG_fail;
41815 }
41816 {
41817 resultobj = wxPyMake_wxObject(result, (bool)0);
41818 }
41819 {
41820 if (temp3)
41821 delete arg3;
41822 }
41823 {
41824 if (temp4)
41825 delete arg4;
41826 }
41827 return resultobj;
41828 fail:
41829 {
41830 if (temp3)
41831 delete arg3;
41832 }
41833 {
41834 if (temp4)
41835 delete arg4;
41836 }
41837 return NULL;
41838 }
41839
41840
41841 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41842 PyObject *resultobj = 0;
41843 wxMenu *arg1 = (wxMenu *) 0 ;
41844 int arg2 ;
41845 wxString *arg3 = 0 ;
41846 wxString const &arg4_defvalue = wxPyEmptyString ;
41847 wxString *arg4 = (wxString *) &arg4_defvalue ;
41848 wxMenuItem *result = 0 ;
41849 void *argp1 = 0 ;
41850 int res1 = 0 ;
41851 int val2 ;
41852 int ecode2 = 0 ;
41853 bool temp3 = false ;
41854 bool temp4 = false ;
41855 PyObject * obj0 = 0 ;
41856 PyObject * obj1 = 0 ;
41857 PyObject * obj2 = 0 ;
41858 PyObject * obj3 = 0 ;
41859 char * kwnames[] = {
41860 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
41861 };
41862
41863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41865 if (!SWIG_IsOK(res1)) {
41866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41867 }
41868 arg1 = reinterpret_cast< wxMenu * >(argp1);
41869 ecode2 = SWIG_AsVal_int(obj1, &val2);
41870 if (!SWIG_IsOK(ecode2)) {
41871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
41872 }
41873 arg2 = static_cast< int >(val2);
41874 {
41875 arg3 = wxString_in_helper(obj2);
41876 if (arg3 == NULL) SWIG_fail;
41877 temp3 = true;
41878 }
41879 if (obj3) {
41880 {
41881 arg4 = wxString_in_helper(obj3);
41882 if (arg4 == NULL) SWIG_fail;
41883 temp4 = true;
41884 }
41885 }
41886 {
41887 PyThreadState* __tstate = wxPyBeginAllowThreads();
41888 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
41889 wxPyEndAllowThreads(__tstate);
41890 if (PyErr_Occurred()) SWIG_fail;
41891 }
41892 {
41893 resultobj = wxPyMake_wxObject(result, (bool)0);
41894 }
41895 {
41896 if (temp3)
41897 delete arg3;
41898 }
41899 {
41900 if (temp4)
41901 delete arg4;
41902 }
41903 return resultobj;
41904 fail:
41905 {
41906 if (temp3)
41907 delete arg3;
41908 }
41909 {
41910 if (temp4)
41911 delete arg4;
41912 }
41913 return NULL;
41914 }
41915
41916
41917 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41918 PyObject *resultobj = 0;
41919 wxMenu *arg1 = (wxMenu *) 0 ;
41920 int arg2 ;
41921 wxString *arg3 = 0 ;
41922 wxMenu *arg4 = (wxMenu *) 0 ;
41923 wxString const &arg5_defvalue = wxPyEmptyString ;
41924 wxString *arg5 = (wxString *) &arg5_defvalue ;
41925 wxMenuItem *result = 0 ;
41926 void *argp1 = 0 ;
41927 int res1 = 0 ;
41928 int val2 ;
41929 int ecode2 = 0 ;
41930 bool temp3 = false ;
41931 void *argp4 = 0 ;
41932 int res4 = 0 ;
41933 bool temp5 = false ;
41934 PyObject * obj0 = 0 ;
41935 PyObject * obj1 = 0 ;
41936 PyObject * obj2 = 0 ;
41937 PyObject * obj3 = 0 ;
41938 PyObject * obj4 = 0 ;
41939 char * kwnames[] = {
41940 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
41941 };
41942
41943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
41944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41945 if (!SWIG_IsOK(res1)) {
41946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
41947 }
41948 arg1 = reinterpret_cast< wxMenu * >(argp1);
41949 ecode2 = SWIG_AsVal_int(obj1, &val2);
41950 if (!SWIG_IsOK(ecode2)) {
41951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
41952 }
41953 arg2 = static_cast< int >(val2);
41954 {
41955 arg3 = wxString_in_helper(obj2);
41956 if (arg3 == NULL) SWIG_fail;
41957 temp3 = true;
41958 }
41959 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
41960 if (!SWIG_IsOK(res4)) {
41961 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
41962 }
41963 arg4 = reinterpret_cast< wxMenu * >(argp4);
41964 if (obj4) {
41965 {
41966 arg5 = wxString_in_helper(obj4);
41967 if (arg5 == NULL) SWIG_fail;
41968 temp5 = true;
41969 }
41970 }
41971 {
41972 PyThreadState* __tstate = wxPyBeginAllowThreads();
41973 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
41974 wxPyEndAllowThreads(__tstate);
41975 if (PyErr_Occurred()) SWIG_fail;
41976 }
41977 {
41978 resultobj = wxPyMake_wxObject(result, (bool)0);
41979 }
41980 {
41981 if (temp3)
41982 delete arg3;
41983 }
41984 {
41985 if (temp5)
41986 delete arg5;
41987 }
41988 return resultobj;
41989 fail:
41990 {
41991 if (temp3)
41992 delete arg3;
41993 }
41994 {
41995 if (temp5)
41996 delete arg5;
41997 }
41998 return NULL;
41999 }
42000
42001
42002 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42003 PyObject *resultobj = 0;
42004 wxMenu *arg1 = (wxMenu *) 0 ;
42005 wxMenu *arg2 = (wxMenu *) 0 ;
42006 wxString *arg3 = 0 ;
42007 wxString const &arg4_defvalue = wxPyEmptyString ;
42008 wxString *arg4 = (wxString *) &arg4_defvalue ;
42009 wxMenuItem *result = 0 ;
42010 void *argp1 = 0 ;
42011 int res1 = 0 ;
42012 void *argp2 = 0 ;
42013 int res2 = 0 ;
42014 bool temp3 = false ;
42015 bool temp4 = false ;
42016 PyObject * obj0 = 0 ;
42017 PyObject * obj1 = 0 ;
42018 PyObject * obj2 = 0 ;
42019 PyObject * obj3 = 0 ;
42020 char * kwnames[] = {
42021 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
42022 };
42023
42024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42026 if (!SWIG_IsOK(res1)) {
42027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42028 }
42029 arg1 = reinterpret_cast< wxMenu * >(argp1);
42030 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42031 if (!SWIG_IsOK(res2)) {
42032 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42033 }
42034 arg2 = reinterpret_cast< wxMenu * >(argp2);
42035 {
42036 arg3 = wxString_in_helper(obj2);
42037 if (arg3 == NULL) SWIG_fail;
42038 temp3 = true;
42039 }
42040 if (obj3) {
42041 {
42042 arg4 = wxString_in_helper(obj3);
42043 if (arg4 == NULL) SWIG_fail;
42044 temp4 = true;
42045 }
42046 }
42047 {
42048 PyThreadState* __tstate = wxPyBeginAllowThreads();
42049 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42050 wxPyEndAllowThreads(__tstate);
42051 if (PyErr_Occurred()) SWIG_fail;
42052 }
42053 {
42054 resultobj = wxPyMake_wxObject(result, (bool)0);
42055 }
42056 {
42057 if (temp3)
42058 delete arg3;
42059 }
42060 {
42061 if (temp4)
42062 delete arg4;
42063 }
42064 return resultobj;
42065 fail:
42066 {
42067 if (temp3)
42068 delete arg3;
42069 }
42070 {
42071 if (temp4)
42072 delete arg4;
42073 }
42074 return NULL;
42075 }
42076
42077
42078 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42079 PyObject *resultobj = 0;
42080 wxMenu *arg1 = (wxMenu *) 0 ;
42081 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42082 wxMenuItem *result = 0 ;
42083 void *argp1 = 0 ;
42084 int res1 = 0 ;
42085 int res2 = 0 ;
42086 PyObject * obj0 = 0 ;
42087 PyObject * obj1 = 0 ;
42088 char * kwnames[] = {
42089 (char *) "self",(char *) "item", NULL
42090 };
42091
42092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
42093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42094 if (!SWIG_IsOK(res1)) {
42095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42096 }
42097 arg1 = reinterpret_cast< wxMenu * >(argp1);
42098 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42099 if (!SWIG_IsOK(res2)) {
42100 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42101 }
42102 {
42103 PyThreadState* __tstate = wxPyBeginAllowThreads();
42104 result = (wxMenuItem *)(arg1)->Append(arg2);
42105 wxPyEndAllowThreads(__tstate);
42106 if (PyErr_Occurred()) SWIG_fail;
42107 }
42108 {
42109 resultobj = wxPyMake_wxObject(result, (bool)0);
42110 }
42111 return resultobj;
42112 fail:
42113 return NULL;
42114 }
42115
42116
42117 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42118 PyObject *resultobj = 0;
42119 wxMenu *arg1 = (wxMenu *) 0 ;
42120 size_t arg2 ;
42121 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
42122 wxMenuItem *result = 0 ;
42123 void *argp1 = 0 ;
42124 int res1 = 0 ;
42125 size_t val2 ;
42126 int ecode2 = 0 ;
42127 int res3 = 0 ;
42128 PyObject * obj0 = 0 ;
42129 PyObject * obj1 = 0 ;
42130 PyObject * obj2 = 0 ;
42131 char * kwnames[] = {
42132 (char *) "self",(char *) "pos",(char *) "item", NULL
42133 };
42134
42135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42137 if (!SWIG_IsOK(res1)) {
42138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42139 }
42140 arg1 = reinterpret_cast< wxMenu * >(argp1);
42141 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42142 if (!SWIG_IsOK(ecode2)) {
42143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
42144 }
42145 arg2 = static_cast< size_t >(val2);
42146 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42147 if (!SWIG_IsOK(res3)) {
42148 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
42149 }
42150 {
42151 PyThreadState* __tstate = wxPyBeginAllowThreads();
42152 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
42153 wxPyEndAllowThreads(__tstate);
42154 if (PyErr_Occurred()) SWIG_fail;
42155 }
42156 {
42157 resultobj = wxPyMake_wxObject(result, (bool)0);
42158 }
42159 return resultobj;
42160 fail:
42161 return NULL;
42162 }
42163
42164
42165 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42166 PyObject *resultobj = 0;
42167 wxMenu *arg1 = (wxMenu *) 0 ;
42168 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42169 wxMenuItem *result = 0 ;
42170 void *argp1 = 0 ;
42171 int res1 = 0 ;
42172 int res2 = 0 ;
42173 PyObject * obj0 = 0 ;
42174 PyObject * obj1 = 0 ;
42175 char * kwnames[] = {
42176 (char *) "self",(char *) "item", NULL
42177 };
42178
42179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
42180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42181 if (!SWIG_IsOK(res1)) {
42182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42183 }
42184 arg1 = reinterpret_cast< wxMenu * >(argp1);
42185 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42186 if (!SWIG_IsOK(res2)) {
42187 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42188 }
42189 {
42190 PyThreadState* __tstate = wxPyBeginAllowThreads();
42191 result = (wxMenuItem *)(arg1)->Prepend(arg2);
42192 wxPyEndAllowThreads(__tstate);
42193 if (PyErr_Occurred()) SWIG_fail;
42194 }
42195 {
42196 resultobj = wxPyMake_wxObject(result, (bool)0);
42197 }
42198 return resultobj;
42199 fail:
42200 return NULL;
42201 }
42202
42203
42204 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42205 PyObject *resultobj = 0;
42206 wxMenu *arg1 = (wxMenu *) 0 ;
42207 void *argp1 = 0 ;
42208 int res1 = 0 ;
42209 PyObject *swig_obj[1] ;
42210
42211 if (!args) SWIG_fail;
42212 swig_obj[0] = args;
42213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42214 if (!SWIG_IsOK(res1)) {
42215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
42216 }
42217 arg1 = reinterpret_cast< wxMenu * >(argp1);
42218 {
42219 PyThreadState* __tstate = wxPyBeginAllowThreads();
42220 (arg1)->Break();
42221 wxPyEndAllowThreads(__tstate);
42222 if (PyErr_Occurred()) SWIG_fail;
42223 }
42224 resultobj = SWIG_Py_Void();
42225 return resultobj;
42226 fail:
42227 return NULL;
42228 }
42229
42230
42231 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42232 PyObject *resultobj = 0;
42233 wxMenu *arg1 = (wxMenu *) 0 ;
42234 size_t arg2 ;
42235 int arg3 ;
42236 wxString const &arg4_defvalue = wxPyEmptyString ;
42237 wxString *arg4 = (wxString *) &arg4_defvalue ;
42238 wxString const &arg5_defvalue = wxPyEmptyString ;
42239 wxString *arg5 = (wxString *) &arg5_defvalue ;
42240 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
42241 wxMenuItem *result = 0 ;
42242 void *argp1 = 0 ;
42243 int res1 = 0 ;
42244 size_t val2 ;
42245 int ecode2 = 0 ;
42246 int val3 ;
42247 int ecode3 = 0 ;
42248 bool temp4 = false ;
42249 bool temp5 = false ;
42250 int val6 ;
42251 int ecode6 = 0 ;
42252 PyObject * obj0 = 0 ;
42253 PyObject * obj1 = 0 ;
42254 PyObject * obj2 = 0 ;
42255 PyObject * obj3 = 0 ;
42256 PyObject * obj4 = 0 ;
42257 PyObject * obj5 = 0 ;
42258 char * kwnames[] = {
42259 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42260 };
42261
42262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42264 if (!SWIG_IsOK(res1)) {
42265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
42266 }
42267 arg1 = reinterpret_cast< wxMenu * >(argp1);
42268 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42269 if (!SWIG_IsOK(ecode2)) {
42270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
42271 }
42272 arg2 = static_cast< size_t >(val2);
42273 ecode3 = SWIG_AsVal_int(obj2, &val3);
42274 if (!SWIG_IsOK(ecode3)) {
42275 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
42276 }
42277 arg3 = static_cast< int >(val3);
42278 if (obj3) {
42279 {
42280 arg4 = wxString_in_helper(obj3);
42281 if (arg4 == NULL) SWIG_fail;
42282 temp4 = true;
42283 }
42284 }
42285 if (obj4) {
42286 {
42287 arg5 = wxString_in_helper(obj4);
42288 if (arg5 == NULL) SWIG_fail;
42289 temp5 = true;
42290 }
42291 }
42292 if (obj5) {
42293 ecode6 = SWIG_AsVal_int(obj5, &val6);
42294 if (!SWIG_IsOK(ecode6)) {
42295 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
42296 }
42297 arg6 = static_cast< wxItemKind >(val6);
42298 }
42299 {
42300 PyThreadState* __tstate = wxPyBeginAllowThreads();
42301 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
42302 wxPyEndAllowThreads(__tstate);
42303 if (PyErr_Occurred()) SWIG_fail;
42304 }
42305 {
42306 resultobj = wxPyMake_wxObject(result, (bool)0);
42307 }
42308 {
42309 if (temp4)
42310 delete arg4;
42311 }
42312 {
42313 if (temp5)
42314 delete arg5;
42315 }
42316 return resultobj;
42317 fail:
42318 {
42319 if (temp4)
42320 delete arg4;
42321 }
42322 {
42323 if (temp5)
42324 delete arg5;
42325 }
42326 return NULL;
42327 }
42328
42329
42330 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42331 PyObject *resultobj = 0;
42332 wxMenu *arg1 = (wxMenu *) 0 ;
42333 size_t arg2 ;
42334 wxMenuItem *result = 0 ;
42335 void *argp1 = 0 ;
42336 int res1 = 0 ;
42337 size_t val2 ;
42338 int ecode2 = 0 ;
42339 PyObject * obj0 = 0 ;
42340 PyObject * obj1 = 0 ;
42341 char * kwnames[] = {
42342 (char *) "self",(char *) "pos", NULL
42343 };
42344
42345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
42346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42347 if (!SWIG_IsOK(res1)) {
42348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42349 }
42350 arg1 = reinterpret_cast< wxMenu * >(argp1);
42351 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42352 if (!SWIG_IsOK(ecode2)) {
42353 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
42354 }
42355 arg2 = static_cast< size_t >(val2);
42356 {
42357 PyThreadState* __tstate = wxPyBeginAllowThreads();
42358 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
42359 wxPyEndAllowThreads(__tstate);
42360 if (PyErr_Occurred()) SWIG_fail;
42361 }
42362 {
42363 resultobj = wxPyMake_wxObject(result, (bool)0);
42364 }
42365 return resultobj;
42366 fail:
42367 return NULL;
42368 }
42369
42370
42371 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42372 PyObject *resultobj = 0;
42373 wxMenu *arg1 = (wxMenu *) 0 ;
42374 size_t arg2 ;
42375 int arg3 ;
42376 wxString *arg4 = 0 ;
42377 wxString const &arg5_defvalue = wxPyEmptyString ;
42378 wxString *arg5 = (wxString *) &arg5_defvalue ;
42379 wxMenuItem *result = 0 ;
42380 void *argp1 = 0 ;
42381 int res1 = 0 ;
42382 size_t val2 ;
42383 int ecode2 = 0 ;
42384 int val3 ;
42385 int ecode3 = 0 ;
42386 bool temp4 = false ;
42387 bool temp5 = false ;
42388 PyObject * obj0 = 0 ;
42389 PyObject * obj1 = 0 ;
42390 PyObject * obj2 = 0 ;
42391 PyObject * obj3 = 0 ;
42392 PyObject * obj4 = 0 ;
42393 char * kwnames[] = {
42394 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42395 };
42396
42397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42399 if (!SWIG_IsOK(res1)) {
42400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42401 }
42402 arg1 = reinterpret_cast< wxMenu * >(argp1);
42403 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42404 if (!SWIG_IsOK(ecode2)) {
42405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
42406 }
42407 arg2 = static_cast< size_t >(val2);
42408 ecode3 = SWIG_AsVal_int(obj2, &val3);
42409 if (!SWIG_IsOK(ecode3)) {
42410 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
42411 }
42412 arg3 = static_cast< int >(val3);
42413 {
42414 arg4 = wxString_in_helper(obj3);
42415 if (arg4 == NULL) SWIG_fail;
42416 temp4 = true;
42417 }
42418 if (obj4) {
42419 {
42420 arg5 = wxString_in_helper(obj4);
42421 if (arg5 == NULL) SWIG_fail;
42422 temp5 = true;
42423 }
42424 }
42425 {
42426 PyThreadState* __tstate = wxPyBeginAllowThreads();
42427 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42428 wxPyEndAllowThreads(__tstate);
42429 if (PyErr_Occurred()) SWIG_fail;
42430 }
42431 {
42432 resultobj = wxPyMake_wxObject(result, (bool)0);
42433 }
42434 {
42435 if (temp4)
42436 delete arg4;
42437 }
42438 {
42439 if (temp5)
42440 delete arg5;
42441 }
42442 return resultobj;
42443 fail:
42444 {
42445 if (temp4)
42446 delete arg4;
42447 }
42448 {
42449 if (temp5)
42450 delete arg5;
42451 }
42452 return NULL;
42453 }
42454
42455
42456 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42457 PyObject *resultobj = 0;
42458 wxMenu *arg1 = (wxMenu *) 0 ;
42459 size_t arg2 ;
42460 int arg3 ;
42461 wxString *arg4 = 0 ;
42462 wxString const &arg5_defvalue = wxPyEmptyString ;
42463 wxString *arg5 = (wxString *) &arg5_defvalue ;
42464 wxMenuItem *result = 0 ;
42465 void *argp1 = 0 ;
42466 int res1 = 0 ;
42467 size_t val2 ;
42468 int ecode2 = 0 ;
42469 int val3 ;
42470 int ecode3 = 0 ;
42471 bool temp4 = false ;
42472 bool temp5 = false ;
42473 PyObject * obj0 = 0 ;
42474 PyObject * obj1 = 0 ;
42475 PyObject * obj2 = 0 ;
42476 PyObject * obj3 = 0 ;
42477 PyObject * obj4 = 0 ;
42478 char * kwnames[] = {
42479 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42480 };
42481
42482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42484 if (!SWIG_IsOK(res1)) {
42485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42486 }
42487 arg1 = reinterpret_cast< wxMenu * >(argp1);
42488 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42489 if (!SWIG_IsOK(ecode2)) {
42490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
42491 }
42492 arg2 = static_cast< size_t >(val2);
42493 ecode3 = SWIG_AsVal_int(obj2, &val3);
42494 if (!SWIG_IsOK(ecode3)) {
42495 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
42496 }
42497 arg3 = static_cast< int >(val3);
42498 {
42499 arg4 = wxString_in_helper(obj3);
42500 if (arg4 == NULL) SWIG_fail;
42501 temp4 = true;
42502 }
42503 if (obj4) {
42504 {
42505 arg5 = wxString_in_helper(obj4);
42506 if (arg5 == NULL) SWIG_fail;
42507 temp5 = true;
42508 }
42509 }
42510 {
42511 PyThreadState* __tstate = wxPyBeginAllowThreads();
42512 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42513 wxPyEndAllowThreads(__tstate);
42514 if (PyErr_Occurred()) SWIG_fail;
42515 }
42516 {
42517 resultobj = wxPyMake_wxObject(result, (bool)0);
42518 }
42519 {
42520 if (temp4)
42521 delete arg4;
42522 }
42523 {
42524 if (temp5)
42525 delete arg5;
42526 }
42527 return resultobj;
42528 fail:
42529 {
42530 if (temp4)
42531 delete arg4;
42532 }
42533 {
42534 if (temp5)
42535 delete arg5;
42536 }
42537 return NULL;
42538 }
42539
42540
42541 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42542 PyObject *resultobj = 0;
42543 wxMenu *arg1 = (wxMenu *) 0 ;
42544 size_t arg2 ;
42545 int arg3 ;
42546 wxString *arg4 = 0 ;
42547 wxMenu *arg5 = (wxMenu *) 0 ;
42548 wxString const &arg6_defvalue = wxPyEmptyString ;
42549 wxString *arg6 = (wxString *) &arg6_defvalue ;
42550 wxMenuItem *result = 0 ;
42551 void *argp1 = 0 ;
42552 int res1 = 0 ;
42553 size_t val2 ;
42554 int ecode2 = 0 ;
42555 int val3 ;
42556 int ecode3 = 0 ;
42557 bool temp4 = false ;
42558 void *argp5 = 0 ;
42559 int res5 = 0 ;
42560 bool temp6 = false ;
42561 PyObject * obj0 = 0 ;
42562 PyObject * obj1 = 0 ;
42563 PyObject * obj2 = 0 ;
42564 PyObject * obj3 = 0 ;
42565 PyObject * obj4 = 0 ;
42566 PyObject * obj5 = 0 ;
42567 char * kwnames[] = {
42568 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42569 };
42570
42571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42573 if (!SWIG_IsOK(res1)) {
42574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42575 }
42576 arg1 = reinterpret_cast< wxMenu * >(argp1);
42577 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42578 if (!SWIG_IsOK(ecode2)) {
42579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
42580 }
42581 arg2 = static_cast< size_t >(val2);
42582 ecode3 = SWIG_AsVal_int(obj2, &val3);
42583 if (!SWIG_IsOK(ecode3)) {
42584 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
42585 }
42586 arg3 = static_cast< int >(val3);
42587 {
42588 arg4 = wxString_in_helper(obj3);
42589 if (arg4 == NULL) SWIG_fail;
42590 temp4 = true;
42591 }
42592 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
42593 if (!SWIG_IsOK(res5)) {
42594 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
42595 }
42596 arg5 = reinterpret_cast< wxMenu * >(argp5);
42597 if (obj5) {
42598 {
42599 arg6 = wxString_in_helper(obj5);
42600 if (arg6 == NULL) SWIG_fail;
42601 temp6 = true;
42602 }
42603 }
42604 {
42605 PyThreadState* __tstate = wxPyBeginAllowThreads();
42606 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
42607 wxPyEndAllowThreads(__tstate);
42608 if (PyErr_Occurred()) SWIG_fail;
42609 }
42610 {
42611 resultobj = wxPyMake_wxObject(result, (bool)0);
42612 }
42613 {
42614 if (temp4)
42615 delete arg4;
42616 }
42617 {
42618 if (temp6)
42619 delete arg6;
42620 }
42621 return resultobj;
42622 fail:
42623 {
42624 if (temp4)
42625 delete arg4;
42626 }
42627 {
42628 if (temp6)
42629 delete arg6;
42630 }
42631 return NULL;
42632 }
42633
42634
42635 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42636 PyObject *resultobj = 0;
42637 wxMenu *arg1 = (wxMenu *) 0 ;
42638 int arg2 ;
42639 wxString const &arg3_defvalue = wxPyEmptyString ;
42640 wxString *arg3 = (wxString *) &arg3_defvalue ;
42641 wxString const &arg4_defvalue = wxPyEmptyString ;
42642 wxString *arg4 = (wxString *) &arg4_defvalue ;
42643 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42644 wxMenuItem *result = 0 ;
42645 void *argp1 = 0 ;
42646 int res1 = 0 ;
42647 int val2 ;
42648 int ecode2 = 0 ;
42649 bool temp3 = false ;
42650 bool temp4 = false ;
42651 int val5 ;
42652 int ecode5 = 0 ;
42653 PyObject * obj0 = 0 ;
42654 PyObject * obj1 = 0 ;
42655 PyObject * obj2 = 0 ;
42656 PyObject * obj3 = 0 ;
42657 PyObject * obj4 = 0 ;
42658 char * kwnames[] = {
42659 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42660 };
42661
42662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42664 if (!SWIG_IsOK(res1)) {
42665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
42666 }
42667 arg1 = reinterpret_cast< wxMenu * >(argp1);
42668 ecode2 = SWIG_AsVal_int(obj1, &val2);
42669 if (!SWIG_IsOK(ecode2)) {
42670 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
42671 }
42672 arg2 = static_cast< int >(val2);
42673 if (obj2) {
42674 {
42675 arg3 = wxString_in_helper(obj2);
42676 if (arg3 == NULL) SWIG_fail;
42677 temp3 = true;
42678 }
42679 }
42680 if (obj3) {
42681 {
42682 arg4 = wxString_in_helper(obj3);
42683 if (arg4 == NULL) SWIG_fail;
42684 temp4 = true;
42685 }
42686 }
42687 if (obj4) {
42688 ecode5 = SWIG_AsVal_int(obj4, &val5);
42689 if (!SWIG_IsOK(ecode5)) {
42690 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
42691 }
42692 arg5 = static_cast< wxItemKind >(val5);
42693 }
42694 {
42695 PyThreadState* __tstate = wxPyBeginAllowThreads();
42696 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
42697 wxPyEndAllowThreads(__tstate);
42698 if (PyErr_Occurred()) SWIG_fail;
42699 }
42700 {
42701 resultobj = wxPyMake_wxObject(result, (bool)0);
42702 }
42703 {
42704 if (temp3)
42705 delete arg3;
42706 }
42707 {
42708 if (temp4)
42709 delete arg4;
42710 }
42711 return resultobj;
42712 fail:
42713 {
42714 if (temp3)
42715 delete arg3;
42716 }
42717 {
42718 if (temp4)
42719 delete arg4;
42720 }
42721 return NULL;
42722 }
42723
42724
42725 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42726 PyObject *resultobj = 0;
42727 wxMenu *arg1 = (wxMenu *) 0 ;
42728 wxMenuItem *result = 0 ;
42729 void *argp1 = 0 ;
42730 int res1 = 0 ;
42731 PyObject *swig_obj[1] ;
42732
42733 if (!args) SWIG_fail;
42734 swig_obj[0] = args;
42735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42736 if (!SWIG_IsOK(res1)) {
42737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42738 }
42739 arg1 = reinterpret_cast< wxMenu * >(argp1);
42740 {
42741 PyThreadState* __tstate = wxPyBeginAllowThreads();
42742 result = (wxMenuItem *)(arg1)->PrependSeparator();
42743 wxPyEndAllowThreads(__tstate);
42744 if (PyErr_Occurred()) SWIG_fail;
42745 }
42746 {
42747 resultobj = wxPyMake_wxObject(result, (bool)0);
42748 }
42749 return resultobj;
42750 fail:
42751 return NULL;
42752 }
42753
42754
42755 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42756 PyObject *resultobj = 0;
42757 wxMenu *arg1 = (wxMenu *) 0 ;
42758 int arg2 ;
42759 wxString *arg3 = 0 ;
42760 wxString const &arg4_defvalue = wxPyEmptyString ;
42761 wxString *arg4 = (wxString *) &arg4_defvalue ;
42762 wxMenuItem *result = 0 ;
42763 void *argp1 = 0 ;
42764 int res1 = 0 ;
42765 int val2 ;
42766 int ecode2 = 0 ;
42767 bool temp3 = false ;
42768 bool temp4 = false ;
42769 PyObject * obj0 = 0 ;
42770 PyObject * obj1 = 0 ;
42771 PyObject * obj2 = 0 ;
42772 PyObject * obj3 = 0 ;
42773 char * kwnames[] = {
42774 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42775 };
42776
42777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42779 if (!SWIG_IsOK(res1)) {
42780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42781 }
42782 arg1 = reinterpret_cast< wxMenu * >(argp1);
42783 ecode2 = SWIG_AsVal_int(obj1, &val2);
42784 if (!SWIG_IsOK(ecode2)) {
42785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
42786 }
42787 arg2 = static_cast< int >(val2);
42788 {
42789 arg3 = wxString_in_helper(obj2);
42790 if (arg3 == NULL) SWIG_fail;
42791 temp3 = true;
42792 }
42793 if (obj3) {
42794 {
42795 arg4 = wxString_in_helper(obj3);
42796 if (arg4 == NULL) SWIG_fail;
42797 temp4 = true;
42798 }
42799 }
42800 {
42801 PyThreadState* __tstate = wxPyBeginAllowThreads();
42802 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42803 wxPyEndAllowThreads(__tstate);
42804 if (PyErr_Occurred()) SWIG_fail;
42805 }
42806 {
42807 resultobj = wxPyMake_wxObject(result, (bool)0);
42808 }
42809 {
42810 if (temp3)
42811 delete arg3;
42812 }
42813 {
42814 if (temp4)
42815 delete arg4;
42816 }
42817 return resultobj;
42818 fail:
42819 {
42820 if (temp3)
42821 delete arg3;
42822 }
42823 {
42824 if (temp4)
42825 delete arg4;
42826 }
42827 return NULL;
42828 }
42829
42830
42831 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42832 PyObject *resultobj = 0;
42833 wxMenu *arg1 = (wxMenu *) 0 ;
42834 int arg2 ;
42835 wxString *arg3 = 0 ;
42836 wxString const &arg4_defvalue = wxPyEmptyString ;
42837 wxString *arg4 = (wxString *) &arg4_defvalue ;
42838 wxMenuItem *result = 0 ;
42839 void *argp1 = 0 ;
42840 int res1 = 0 ;
42841 int val2 ;
42842 int ecode2 = 0 ;
42843 bool temp3 = false ;
42844 bool temp4 = false ;
42845 PyObject * obj0 = 0 ;
42846 PyObject * obj1 = 0 ;
42847 PyObject * obj2 = 0 ;
42848 PyObject * obj3 = 0 ;
42849 char * kwnames[] = {
42850 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42851 };
42852
42853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42855 if (!SWIG_IsOK(res1)) {
42856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42857 }
42858 arg1 = reinterpret_cast< wxMenu * >(argp1);
42859 ecode2 = SWIG_AsVal_int(obj1, &val2);
42860 if (!SWIG_IsOK(ecode2)) {
42861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
42862 }
42863 arg2 = static_cast< int >(val2);
42864 {
42865 arg3 = wxString_in_helper(obj2);
42866 if (arg3 == NULL) SWIG_fail;
42867 temp3 = true;
42868 }
42869 if (obj3) {
42870 {
42871 arg4 = wxString_in_helper(obj3);
42872 if (arg4 == NULL) SWIG_fail;
42873 temp4 = true;
42874 }
42875 }
42876 {
42877 PyThreadState* __tstate = wxPyBeginAllowThreads();
42878 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42879 wxPyEndAllowThreads(__tstate);
42880 if (PyErr_Occurred()) SWIG_fail;
42881 }
42882 {
42883 resultobj = wxPyMake_wxObject(result, (bool)0);
42884 }
42885 {
42886 if (temp3)
42887 delete arg3;
42888 }
42889 {
42890 if (temp4)
42891 delete arg4;
42892 }
42893 return resultobj;
42894 fail:
42895 {
42896 if (temp3)
42897 delete arg3;
42898 }
42899 {
42900 if (temp4)
42901 delete arg4;
42902 }
42903 return NULL;
42904 }
42905
42906
42907 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42908 PyObject *resultobj = 0;
42909 wxMenu *arg1 = (wxMenu *) 0 ;
42910 int arg2 ;
42911 wxString *arg3 = 0 ;
42912 wxMenu *arg4 = (wxMenu *) 0 ;
42913 wxString const &arg5_defvalue = wxPyEmptyString ;
42914 wxString *arg5 = (wxString *) &arg5_defvalue ;
42915 wxMenuItem *result = 0 ;
42916 void *argp1 = 0 ;
42917 int res1 = 0 ;
42918 int val2 ;
42919 int ecode2 = 0 ;
42920 bool temp3 = false ;
42921 void *argp4 = 0 ;
42922 int res4 = 0 ;
42923 bool temp5 = false ;
42924 PyObject * obj0 = 0 ;
42925 PyObject * obj1 = 0 ;
42926 PyObject * obj2 = 0 ;
42927 PyObject * obj3 = 0 ;
42928 PyObject * obj4 = 0 ;
42929 char * kwnames[] = {
42930 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42931 };
42932
42933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42935 if (!SWIG_IsOK(res1)) {
42936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42937 }
42938 arg1 = reinterpret_cast< wxMenu * >(argp1);
42939 ecode2 = SWIG_AsVal_int(obj1, &val2);
42940 if (!SWIG_IsOK(ecode2)) {
42941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
42942 }
42943 arg2 = static_cast< int >(val2);
42944 {
42945 arg3 = wxString_in_helper(obj2);
42946 if (arg3 == NULL) SWIG_fail;
42947 temp3 = true;
42948 }
42949 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
42950 if (!SWIG_IsOK(res4)) {
42951 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
42952 }
42953 arg4 = reinterpret_cast< wxMenu * >(argp4);
42954 if (obj4) {
42955 {
42956 arg5 = wxString_in_helper(obj4);
42957 if (arg5 == NULL) SWIG_fail;
42958 temp5 = true;
42959 }
42960 }
42961 {
42962 PyThreadState* __tstate = wxPyBeginAllowThreads();
42963 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
42964 wxPyEndAllowThreads(__tstate);
42965 if (PyErr_Occurred()) SWIG_fail;
42966 }
42967 {
42968 resultobj = wxPyMake_wxObject(result, (bool)0);
42969 }
42970 {
42971 if (temp3)
42972 delete arg3;
42973 }
42974 {
42975 if (temp5)
42976 delete arg5;
42977 }
42978 return resultobj;
42979 fail:
42980 {
42981 if (temp3)
42982 delete arg3;
42983 }
42984 {
42985 if (temp5)
42986 delete arg5;
42987 }
42988 return NULL;
42989 }
42990
42991
42992 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42993 PyObject *resultobj = 0;
42994 wxMenu *arg1 = (wxMenu *) 0 ;
42995 int arg2 ;
42996 wxMenuItem *result = 0 ;
42997 void *argp1 = 0 ;
42998 int res1 = 0 ;
42999 int val2 ;
43000 int ecode2 = 0 ;
43001 PyObject * obj0 = 0 ;
43002 PyObject * obj1 = 0 ;
43003 char * kwnames[] = {
43004 (char *) "self",(char *) "id", NULL
43005 };
43006
43007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
43008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43009 if (!SWIG_IsOK(res1)) {
43010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
43011 }
43012 arg1 = reinterpret_cast< wxMenu * >(argp1);
43013 ecode2 = SWIG_AsVal_int(obj1, &val2);
43014 if (!SWIG_IsOK(ecode2)) {
43015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
43016 }
43017 arg2 = static_cast< int >(val2);
43018 {
43019 PyThreadState* __tstate = wxPyBeginAllowThreads();
43020 result = (wxMenuItem *)(arg1)->Remove(arg2);
43021 wxPyEndAllowThreads(__tstate);
43022 if (PyErr_Occurred()) SWIG_fail;
43023 }
43024 {
43025 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43026 }
43027 return resultobj;
43028 fail:
43029 return NULL;
43030 }
43031
43032
43033 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43034 PyObject *resultobj = 0;
43035 wxMenu *arg1 = (wxMenu *) 0 ;
43036 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43037 wxMenuItem *result = 0 ;
43038 void *argp1 = 0 ;
43039 int res1 = 0 ;
43040 void *argp2 = 0 ;
43041 int res2 = 0 ;
43042 PyObject * obj0 = 0 ;
43043 PyObject * obj1 = 0 ;
43044 char * kwnames[] = {
43045 (char *) "self",(char *) "item", NULL
43046 };
43047
43048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
43049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43050 if (!SWIG_IsOK(res1)) {
43051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43052 }
43053 arg1 = reinterpret_cast< wxMenu * >(argp1);
43054 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43055 if (!SWIG_IsOK(res2)) {
43056 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43057 }
43058 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43059 {
43060 PyThreadState* __tstate = wxPyBeginAllowThreads();
43061 result = (wxMenuItem *)(arg1)->Remove(arg2);
43062 wxPyEndAllowThreads(__tstate);
43063 if (PyErr_Occurred()) SWIG_fail;
43064 }
43065 {
43066 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43067 }
43068 return resultobj;
43069 fail:
43070 return NULL;
43071 }
43072
43073
43074 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43075 PyObject *resultobj = 0;
43076 wxMenu *arg1 = (wxMenu *) 0 ;
43077 int arg2 ;
43078 bool result;
43079 void *argp1 = 0 ;
43080 int res1 = 0 ;
43081 int val2 ;
43082 int ecode2 = 0 ;
43083 PyObject * obj0 = 0 ;
43084 PyObject * obj1 = 0 ;
43085 char * kwnames[] = {
43086 (char *) "self",(char *) "id", NULL
43087 };
43088
43089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
43090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43091 if (!SWIG_IsOK(res1)) {
43092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
43093 }
43094 arg1 = reinterpret_cast< wxMenu * >(argp1);
43095 ecode2 = SWIG_AsVal_int(obj1, &val2);
43096 if (!SWIG_IsOK(ecode2)) {
43097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
43098 }
43099 arg2 = static_cast< int >(val2);
43100 {
43101 PyThreadState* __tstate = wxPyBeginAllowThreads();
43102 result = (bool)(arg1)->Delete(arg2);
43103 wxPyEndAllowThreads(__tstate);
43104 if (PyErr_Occurred()) SWIG_fail;
43105 }
43106 {
43107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43108 }
43109 return resultobj;
43110 fail:
43111 return NULL;
43112 }
43113
43114
43115 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43116 PyObject *resultobj = 0;
43117 wxMenu *arg1 = (wxMenu *) 0 ;
43118 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43119 bool result;
43120 void *argp1 = 0 ;
43121 int res1 = 0 ;
43122 void *argp2 = 0 ;
43123 int res2 = 0 ;
43124 PyObject * obj0 = 0 ;
43125 PyObject * obj1 = 0 ;
43126 char * kwnames[] = {
43127 (char *) "self",(char *) "item", NULL
43128 };
43129
43130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
43131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43132 if (!SWIG_IsOK(res1)) {
43133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43134 }
43135 arg1 = reinterpret_cast< wxMenu * >(argp1);
43136 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43137 if (!SWIG_IsOK(res2)) {
43138 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43139 }
43140 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43141 {
43142 PyThreadState* __tstate = wxPyBeginAllowThreads();
43143 result = (bool)(arg1)->Delete(arg2);
43144 wxPyEndAllowThreads(__tstate);
43145 if (PyErr_Occurred()) SWIG_fail;
43146 }
43147 {
43148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43149 }
43150 return resultobj;
43151 fail:
43152 return NULL;
43153 }
43154
43155
43156 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43157 PyObject *resultobj = 0;
43158 wxMenu *arg1 = (wxMenu *) 0 ;
43159 void *argp1 = 0 ;
43160 int res1 = 0 ;
43161 PyObject *swig_obj[1] ;
43162
43163 if (!args) SWIG_fail;
43164 swig_obj[0] = args;
43165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43166 if (!SWIG_IsOK(res1)) {
43167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
43168 }
43169 arg1 = reinterpret_cast< wxMenu * >(argp1);
43170 {
43171 PyThreadState* __tstate = wxPyBeginAllowThreads();
43172 wxMenu_Destroy(arg1);
43173 wxPyEndAllowThreads(__tstate);
43174 if (PyErr_Occurred()) SWIG_fail;
43175 }
43176 resultobj = SWIG_Py_Void();
43177 return resultobj;
43178 fail:
43179 return NULL;
43180 }
43181
43182
43183 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43184 PyObject *resultobj = 0;
43185 wxMenu *arg1 = (wxMenu *) 0 ;
43186 int arg2 ;
43187 bool result;
43188 void *argp1 = 0 ;
43189 int res1 = 0 ;
43190 int val2 ;
43191 int ecode2 = 0 ;
43192 PyObject * obj0 = 0 ;
43193 PyObject * obj1 = 0 ;
43194 char * kwnames[] = {
43195 (char *) "self",(char *) "id", NULL
43196 };
43197
43198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
43199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43200 if (!SWIG_IsOK(res1)) {
43201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
43202 }
43203 arg1 = reinterpret_cast< wxMenu * >(argp1);
43204 ecode2 = SWIG_AsVal_int(obj1, &val2);
43205 if (!SWIG_IsOK(ecode2)) {
43206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
43207 }
43208 arg2 = static_cast< int >(val2);
43209 {
43210 PyThreadState* __tstate = wxPyBeginAllowThreads();
43211 result = (bool)(arg1)->Destroy(arg2);
43212 wxPyEndAllowThreads(__tstate);
43213 if (PyErr_Occurred()) SWIG_fail;
43214 }
43215 {
43216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43217 }
43218 return resultobj;
43219 fail:
43220 return NULL;
43221 }
43222
43223
43224 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43225 PyObject *resultobj = 0;
43226 wxMenu *arg1 = (wxMenu *) 0 ;
43227 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43228 bool result;
43229 void *argp1 = 0 ;
43230 int res1 = 0 ;
43231 void *argp2 = 0 ;
43232 int res2 = 0 ;
43233 PyObject * obj0 = 0 ;
43234 PyObject * obj1 = 0 ;
43235 char * kwnames[] = {
43236 (char *) "self",(char *) "item", NULL
43237 };
43238
43239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
43240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43241 if (!SWIG_IsOK(res1)) {
43242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43243 }
43244 arg1 = reinterpret_cast< wxMenu * >(argp1);
43245 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43246 if (!SWIG_IsOK(res2)) {
43247 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43248 }
43249 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43250 {
43251 PyThreadState* __tstate = wxPyBeginAllowThreads();
43252 result = (bool)(arg1)->Destroy(arg2);
43253 wxPyEndAllowThreads(__tstate);
43254 if (PyErr_Occurred()) SWIG_fail;
43255 }
43256 {
43257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43258 }
43259 return resultobj;
43260 fail:
43261 return NULL;
43262 }
43263
43264
43265 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43266 PyObject *resultobj = 0;
43267 wxMenu *arg1 = (wxMenu *) 0 ;
43268 size_t result;
43269 void *argp1 = 0 ;
43270 int res1 = 0 ;
43271 PyObject *swig_obj[1] ;
43272
43273 if (!args) SWIG_fail;
43274 swig_obj[0] = args;
43275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43276 if (!SWIG_IsOK(res1)) {
43277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
43278 }
43279 arg1 = reinterpret_cast< wxMenu * >(argp1);
43280 {
43281 PyThreadState* __tstate = wxPyBeginAllowThreads();
43282 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
43283 wxPyEndAllowThreads(__tstate);
43284 if (PyErr_Occurred()) SWIG_fail;
43285 }
43286 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
43287 return resultobj;
43288 fail:
43289 return NULL;
43290 }
43291
43292
43293 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43294 PyObject *resultobj = 0;
43295 wxMenu *arg1 = (wxMenu *) 0 ;
43296 PyObject *result = 0 ;
43297 void *argp1 = 0 ;
43298 int res1 = 0 ;
43299 PyObject *swig_obj[1] ;
43300
43301 if (!args) SWIG_fail;
43302 swig_obj[0] = args;
43303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43304 if (!SWIG_IsOK(res1)) {
43305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
43306 }
43307 arg1 = reinterpret_cast< wxMenu * >(argp1);
43308 {
43309 PyThreadState* __tstate = wxPyBeginAllowThreads();
43310 result = (PyObject *)wxMenu_GetMenuItems(arg1);
43311 wxPyEndAllowThreads(__tstate);
43312 if (PyErr_Occurred()) SWIG_fail;
43313 }
43314 resultobj = result;
43315 return resultobj;
43316 fail:
43317 return NULL;
43318 }
43319
43320
43321 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43322 PyObject *resultobj = 0;
43323 wxMenu *arg1 = (wxMenu *) 0 ;
43324 wxString *arg2 = 0 ;
43325 int result;
43326 void *argp1 = 0 ;
43327 int res1 = 0 ;
43328 bool temp2 = false ;
43329 PyObject * obj0 = 0 ;
43330 PyObject * obj1 = 0 ;
43331 char * kwnames[] = {
43332 (char *) "self",(char *) "item", NULL
43333 };
43334
43335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
43336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43337 if (!SWIG_IsOK(res1)) {
43338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
43339 }
43340 arg1 = reinterpret_cast< wxMenu * >(argp1);
43341 {
43342 arg2 = wxString_in_helper(obj1);
43343 if (arg2 == NULL) SWIG_fail;
43344 temp2 = true;
43345 }
43346 {
43347 PyThreadState* __tstate = wxPyBeginAllowThreads();
43348 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
43349 wxPyEndAllowThreads(__tstate);
43350 if (PyErr_Occurred()) SWIG_fail;
43351 }
43352 resultobj = SWIG_From_int(static_cast< int >(result));
43353 {
43354 if (temp2)
43355 delete arg2;
43356 }
43357 return resultobj;
43358 fail:
43359 {
43360 if (temp2)
43361 delete arg2;
43362 }
43363 return NULL;
43364 }
43365
43366
43367 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43368 PyObject *resultobj = 0;
43369 wxMenu *arg1 = (wxMenu *) 0 ;
43370 int arg2 ;
43371 wxMenuItem *result = 0 ;
43372 void *argp1 = 0 ;
43373 int res1 = 0 ;
43374 int val2 ;
43375 int ecode2 = 0 ;
43376 PyObject * obj0 = 0 ;
43377 PyObject * obj1 = 0 ;
43378 char * kwnames[] = {
43379 (char *) "self",(char *) "id", NULL
43380 };
43381
43382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
43383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43384 if (!SWIG_IsOK(res1)) {
43385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
43386 }
43387 arg1 = reinterpret_cast< wxMenu * >(argp1);
43388 ecode2 = SWIG_AsVal_int(obj1, &val2);
43389 if (!SWIG_IsOK(ecode2)) {
43390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
43391 }
43392 arg2 = static_cast< int >(val2);
43393 {
43394 PyThreadState* __tstate = wxPyBeginAllowThreads();
43395 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
43396 wxPyEndAllowThreads(__tstate);
43397 if (PyErr_Occurred()) SWIG_fail;
43398 }
43399 {
43400 resultobj = wxPyMake_wxObject(result, (bool)0);
43401 }
43402 return resultobj;
43403 fail:
43404 return NULL;
43405 }
43406
43407
43408 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43409 PyObject *resultobj = 0;
43410 wxMenu *arg1 = (wxMenu *) 0 ;
43411 size_t arg2 ;
43412 wxMenuItem *result = 0 ;
43413 void *argp1 = 0 ;
43414 int res1 = 0 ;
43415 size_t val2 ;
43416 int ecode2 = 0 ;
43417 PyObject * obj0 = 0 ;
43418 PyObject * obj1 = 0 ;
43419 char * kwnames[] = {
43420 (char *) "self",(char *) "position", NULL
43421 };
43422
43423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
43424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43425 if (!SWIG_IsOK(res1)) {
43426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
43427 }
43428 arg1 = reinterpret_cast< wxMenu * >(argp1);
43429 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43430 if (!SWIG_IsOK(ecode2)) {
43431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
43432 }
43433 arg2 = static_cast< size_t >(val2);
43434 {
43435 PyThreadState* __tstate = wxPyBeginAllowThreads();
43436 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
43437 wxPyEndAllowThreads(__tstate);
43438 if (PyErr_Occurred()) SWIG_fail;
43439 }
43440 {
43441 resultobj = wxPyMake_wxObject(result, (bool)0);
43442 }
43443 return resultobj;
43444 fail:
43445 return NULL;
43446 }
43447
43448
43449 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43450 PyObject *resultobj = 0;
43451 wxMenu *arg1 = (wxMenu *) 0 ;
43452 int arg2 ;
43453 bool arg3 ;
43454 void *argp1 = 0 ;
43455 int res1 = 0 ;
43456 int val2 ;
43457 int ecode2 = 0 ;
43458 bool val3 ;
43459 int ecode3 = 0 ;
43460 PyObject * obj0 = 0 ;
43461 PyObject * obj1 = 0 ;
43462 PyObject * obj2 = 0 ;
43463 char * kwnames[] = {
43464 (char *) "self",(char *) "id",(char *) "enable", NULL
43465 };
43466
43467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43469 if (!SWIG_IsOK(res1)) {
43470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
43471 }
43472 arg1 = reinterpret_cast< wxMenu * >(argp1);
43473 ecode2 = SWIG_AsVal_int(obj1, &val2);
43474 if (!SWIG_IsOK(ecode2)) {
43475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
43476 }
43477 arg2 = static_cast< int >(val2);
43478 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43479 if (!SWIG_IsOK(ecode3)) {
43480 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
43481 }
43482 arg3 = static_cast< bool >(val3);
43483 {
43484 PyThreadState* __tstate = wxPyBeginAllowThreads();
43485 (arg1)->Enable(arg2,arg3);
43486 wxPyEndAllowThreads(__tstate);
43487 if (PyErr_Occurred()) SWIG_fail;
43488 }
43489 resultobj = SWIG_Py_Void();
43490 return resultobj;
43491 fail:
43492 return NULL;
43493 }
43494
43495
43496 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43497 PyObject *resultobj = 0;
43498 wxMenu *arg1 = (wxMenu *) 0 ;
43499 int arg2 ;
43500 bool result;
43501 void *argp1 = 0 ;
43502 int res1 = 0 ;
43503 int val2 ;
43504 int ecode2 = 0 ;
43505 PyObject * obj0 = 0 ;
43506 PyObject * obj1 = 0 ;
43507 char * kwnames[] = {
43508 (char *) "self",(char *) "id", NULL
43509 };
43510
43511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
43512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43513 if (!SWIG_IsOK(res1)) {
43514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
43515 }
43516 arg1 = reinterpret_cast< wxMenu * >(argp1);
43517 ecode2 = SWIG_AsVal_int(obj1, &val2);
43518 if (!SWIG_IsOK(ecode2)) {
43519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
43520 }
43521 arg2 = static_cast< int >(val2);
43522 {
43523 PyThreadState* __tstate = wxPyBeginAllowThreads();
43524 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
43525 wxPyEndAllowThreads(__tstate);
43526 if (PyErr_Occurred()) SWIG_fail;
43527 }
43528 {
43529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43530 }
43531 return resultobj;
43532 fail:
43533 return NULL;
43534 }
43535
43536
43537 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43538 PyObject *resultobj = 0;
43539 wxMenu *arg1 = (wxMenu *) 0 ;
43540 int arg2 ;
43541 bool arg3 ;
43542 void *argp1 = 0 ;
43543 int res1 = 0 ;
43544 int val2 ;
43545 int ecode2 = 0 ;
43546 bool val3 ;
43547 int ecode3 = 0 ;
43548 PyObject * obj0 = 0 ;
43549 PyObject * obj1 = 0 ;
43550 PyObject * obj2 = 0 ;
43551 char * kwnames[] = {
43552 (char *) "self",(char *) "id",(char *) "check", NULL
43553 };
43554
43555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43557 if (!SWIG_IsOK(res1)) {
43558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
43559 }
43560 arg1 = reinterpret_cast< wxMenu * >(argp1);
43561 ecode2 = SWIG_AsVal_int(obj1, &val2);
43562 if (!SWIG_IsOK(ecode2)) {
43563 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
43564 }
43565 arg2 = static_cast< int >(val2);
43566 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43567 if (!SWIG_IsOK(ecode3)) {
43568 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
43569 }
43570 arg3 = static_cast< bool >(val3);
43571 {
43572 PyThreadState* __tstate = wxPyBeginAllowThreads();
43573 (arg1)->Check(arg2,arg3);
43574 wxPyEndAllowThreads(__tstate);
43575 if (PyErr_Occurred()) SWIG_fail;
43576 }
43577 resultobj = SWIG_Py_Void();
43578 return resultobj;
43579 fail:
43580 return NULL;
43581 }
43582
43583
43584 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43585 PyObject *resultobj = 0;
43586 wxMenu *arg1 = (wxMenu *) 0 ;
43587 int arg2 ;
43588 bool result;
43589 void *argp1 = 0 ;
43590 int res1 = 0 ;
43591 int val2 ;
43592 int ecode2 = 0 ;
43593 PyObject * obj0 = 0 ;
43594 PyObject * obj1 = 0 ;
43595 char * kwnames[] = {
43596 (char *) "self",(char *) "id", NULL
43597 };
43598
43599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
43600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43601 if (!SWIG_IsOK(res1)) {
43602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
43603 }
43604 arg1 = reinterpret_cast< wxMenu * >(argp1);
43605 ecode2 = SWIG_AsVal_int(obj1, &val2);
43606 if (!SWIG_IsOK(ecode2)) {
43607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
43608 }
43609 arg2 = static_cast< int >(val2);
43610 {
43611 PyThreadState* __tstate = wxPyBeginAllowThreads();
43612 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
43613 wxPyEndAllowThreads(__tstate);
43614 if (PyErr_Occurred()) SWIG_fail;
43615 }
43616 {
43617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43618 }
43619 return resultobj;
43620 fail:
43621 return NULL;
43622 }
43623
43624
43625 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43626 PyObject *resultobj = 0;
43627 wxMenu *arg1 = (wxMenu *) 0 ;
43628 int arg2 ;
43629 wxString *arg3 = 0 ;
43630 void *argp1 = 0 ;
43631 int res1 = 0 ;
43632 int val2 ;
43633 int ecode2 = 0 ;
43634 bool temp3 = false ;
43635 PyObject * obj0 = 0 ;
43636 PyObject * obj1 = 0 ;
43637 PyObject * obj2 = 0 ;
43638 char * kwnames[] = {
43639 (char *) "self",(char *) "id",(char *) "label", NULL
43640 };
43641
43642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43644 if (!SWIG_IsOK(res1)) {
43645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
43646 }
43647 arg1 = reinterpret_cast< wxMenu * >(argp1);
43648 ecode2 = SWIG_AsVal_int(obj1, &val2);
43649 if (!SWIG_IsOK(ecode2)) {
43650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
43651 }
43652 arg2 = static_cast< int >(val2);
43653 {
43654 arg3 = wxString_in_helper(obj2);
43655 if (arg3 == NULL) SWIG_fail;
43656 temp3 = true;
43657 }
43658 {
43659 PyThreadState* __tstate = wxPyBeginAllowThreads();
43660 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
43661 wxPyEndAllowThreads(__tstate);
43662 if (PyErr_Occurred()) SWIG_fail;
43663 }
43664 resultobj = SWIG_Py_Void();
43665 {
43666 if (temp3)
43667 delete arg3;
43668 }
43669 return resultobj;
43670 fail:
43671 {
43672 if (temp3)
43673 delete arg3;
43674 }
43675 return NULL;
43676 }
43677
43678
43679 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43680 PyObject *resultobj = 0;
43681 wxMenu *arg1 = (wxMenu *) 0 ;
43682 int arg2 ;
43683 wxString result;
43684 void *argp1 = 0 ;
43685 int res1 = 0 ;
43686 int val2 ;
43687 int ecode2 = 0 ;
43688 PyObject * obj0 = 0 ;
43689 PyObject * obj1 = 0 ;
43690 char * kwnames[] = {
43691 (char *) "self",(char *) "id", NULL
43692 };
43693
43694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
43695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43696 if (!SWIG_IsOK(res1)) {
43697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
43698 }
43699 arg1 = reinterpret_cast< wxMenu * >(argp1);
43700 ecode2 = SWIG_AsVal_int(obj1, &val2);
43701 if (!SWIG_IsOK(ecode2)) {
43702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
43703 }
43704 arg2 = static_cast< int >(val2);
43705 {
43706 PyThreadState* __tstate = wxPyBeginAllowThreads();
43707 result = ((wxMenu const *)arg1)->GetLabel(arg2);
43708 wxPyEndAllowThreads(__tstate);
43709 if (PyErr_Occurred()) SWIG_fail;
43710 }
43711 {
43712 #if wxUSE_UNICODE
43713 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43714 #else
43715 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43716 #endif
43717 }
43718 return resultobj;
43719 fail:
43720 return NULL;
43721 }
43722
43723
43724 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43725 PyObject *resultobj = 0;
43726 wxMenu *arg1 = (wxMenu *) 0 ;
43727 int arg2 ;
43728 wxString *arg3 = 0 ;
43729 void *argp1 = 0 ;
43730 int res1 = 0 ;
43731 int val2 ;
43732 int ecode2 = 0 ;
43733 bool temp3 = false ;
43734 PyObject * obj0 = 0 ;
43735 PyObject * obj1 = 0 ;
43736 PyObject * obj2 = 0 ;
43737 char * kwnames[] = {
43738 (char *) "self",(char *) "id",(char *) "helpString", NULL
43739 };
43740
43741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43743 if (!SWIG_IsOK(res1)) {
43744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
43745 }
43746 arg1 = reinterpret_cast< wxMenu * >(argp1);
43747 ecode2 = SWIG_AsVal_int(obj1, &val2);
43748 if (!SWIG_IsOK(ecode2)) {
43749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
43750 }
43751 arg2 = static_cast< int >(val2);
43752 {
43753 arg3 = wxString_in_helper(obj2);
43754 if (arg3 == NULL) SWIG_fail;
43755 temp3 = true;
43756 }
43757 {
43758 PyThreadState* __tstate = wxPyBeginAllowThreads();
43759 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
43760 wxPyEndAllowThreads(__tstate);
43761 if (PyErr_Occurred()) SWIG_fail;
43762 }
43763 resultobj = SWIG_Py_Void();
43764 {
43765 if (temp3)
43766 delete arg3;
43767 }
43768 return resultobj;
43769 fail:
43770 {
43771 if (temp3)
43772 delete arg3;
43773 }
43774 return NULL;
43775 }
43776
43777
43778 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43779 PyObject *resultobj = 0;
43780 wxMenu *arg1 = (wxMenu *) 0 ;
43781 int arg2 ;
43782 wxString result;
43783 void *argp1 = 0 ;
43784 int res1 = 0 ;
43785 int val2 ;
43786 int ecode2 = 0 ;
43787 PyObject * obj0 = 0 ;
43788 PyObject * obj1 = 0 ;
43789 char * kwnames[] = {
43790 (char *) "self",(char *) "id", NULL
43791 };
43792
43793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
43794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43795 if (!SWIG_IsOK(res1)) {
43796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
43797 }
43798 arg1 = reinterpret_cast< wxMenu * >(argp1);
43799 ecode2 = SWIG_AsVal_int(obj1, &val2);
43800 if (!SWIG_IsOK(ecode2)) {
43801 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
43802 }
43803 arg2 = static_cast< int >(val2);
43804 {
43805 PyThreadState* __tstate = wxPyBeginAllowThreads();
43806 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
43807 wxPyEndAllowThreads(__tstate);
43808 if (PyErr_Occurred()) SWIG_fail;
43809 }
43810 {
43811 #if wxUSE_UNICODE
43812 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43813 #else
43814 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43815 #endif
43816 }
43817 return resultobj;
43818 fail:
43819 return NULL;
43820 }
43821
43822
43823 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43824 PyObject *resultobj = 0;
43825 wxMenu *arg1 = (wxMenu *) 0 ;
43826 wxString *arg2 = 0 ;
43827 void *argp1 = 0 ;
43828 int res1 = 0 ;
43829 bool temp2 = false ;
43830 PyObject * obj0 = 0 ;
43831 PyObject * obj1 = 0 ;
43832 char * kwnames[] = {
43833 (char *) "self",(char *) "title", NULL
43834 };
43835
43836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
43837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43838 if (!SWIG_IsOK(res1)) {
43839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
43840 }
43841 arg1 = reinterpret_cast< wxMenu * >(argp1);
43842 {
43843 arg2 = wxString_in_helper(obj1);
43844 if (arg2 == NULL) SWIG_fail;
43845 temp2 = true;
43846 }
43847 {
43848 PyThreadState* __tstate = wxPyBeginAllowThreads();
43849 (arg1)->SetTitle((wxString const &)*arg2);
43850 wxPyEndAllowThreads(__tstate);
43851 if (PyErr_Occurred()) SWIG_fail;
43852 }
43853 resultobj = SWIG_Py_Void();
43854 {
43855 if (temp2)
43856 delete arg2;
43857 }
43858 return resultobj;
43859 fail:
43860 {
43861 if (temp2)
43862 delete arg2;
43863 }
43864 return NULL;
43865 }
43866
43867
43868 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43869 PyObject *resultobj = 0;
43870 wxMenu *arg1 = (wxMenu *) 0 ;
43871 wxString result;
43872 void *argp1 = 0 ;
43873 int res1 = 0 ;
43874 PyObject *swig_obj[1] ;
43875
43876 if (!args) SWIG_fail;
43877 swig_obj[0] = args;
43878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43879 if (!SWIG_IsOK(res1)) {
43880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
43881 }
43882 arg1 = reinterpret_cast< wxMenu * >(argp1);
43883 {
43884 PyThreadState* __tstate = wxPyBeginAllowThreads();
43885 result = ((wxMenu const *)arg1)->GetTitle();
43886 wxPyEndAllowThreads(__tstate);
43887 if (PyErr_Occurred()) SWIG_fail;
43888 }
43889 {
43890 #if wxUSE_UNICODE
43891 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43892 #else
43893 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43894 #endif
43895 }
43896 return resultobj;
43897 fail:
43898 return NULL;
43899 }
43900
43901
43902 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43903 PyObject *resultobj = 0;
43904 wxMenu *arg1 = (wxMenu *) 0 ;
43905 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
43906 void *argp1 = 0 ;
43907 int res1 = 0 ;
43908 void *argp2 = 0 ;
43909 int res2 = 0 ;
43910 PyObject * obj0 = 0 ;
43911 PyObject * obj1 = 0 ;
43912 char * kwnames[] = {
43913 (char *) "self",(char *) "handler", NULL
43914 };
43915
43916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
43917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43918 if (!SWIG_IsOK(res1)) {
43919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
43920 }
43921 arg1 = reinterpret_cast< wxMenu * >(argp1);
43922 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
43923 if (!SWIG_IsOK(res2)) {
43924 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
43925 }
43926 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
43927 {
43928 PyThreadState* __tstate = wxPyBeginAllowThreads();
43929 (arg1)->SetEventHandler(arg2);
43930 wxPyEndAllowThreads(__tstate);
43931 if (PyErr_Occurred()) SWIG_fail;
43932 }
43933 resultobj = SWIG_Py_Void();
43934 return resultobj;
43935 fail:
43936 return NULL;
43937 }
43938
43939
43940 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43941 PyObject *resultobj = 0;
43942 wxMenu *arg1 = (wxMenu *) 0 ;
43943 wxEvtHandler *result = 0 ;
43944 void *argp1 = 0 ;
43945 int res1 = 0 ;
43946 PyObject *swig_obj[1] ;
43947
43948 if (!args) SWIG_fail;
43949 swig_obj[0] = args;
43950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43951 if (!SWIG_IsOK(res1)) {
43952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
43953 }
43954 arg1 = reinterpret_cast< wxMenu * >(argp1);
43955 {
43956 PyThreadState* __tstate = wxPyBeginAllowThreads();
43957 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
43958 wxPyEndAllowThreads(__tstate);
43959 if (PyErr_Occurred()) SWIG_fail;
43960 }
43961 {
43962 resultobj = wxPyMake_wxObject(result, 0);
43963 }
43964 return resultobj;
43965 fail:
43966 return NULL;
43967 }
43968
43969
43970 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43971 PyObject *resultobj = 0;
43972 wxMenu *arg1 = (wxMenu *) 0 ;
43973 wxWindow *arg2 = (wxWindow *) 0 ;
43974 void *argp1 = 0 ;
43975 int res1 = 0 ;
43976 void *argp2 = 0 ;
43977 int res2 = 0 ;
43978 PyObject * obj0 = 0 ;
43979 PyObject * obj1 = 0 ;
43980 char * kwnames[] = {
43981 (char *) "self",(char *) "win", NULL
43982 };
43983
43984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
43985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43986 if (!SWIG_IsOK(res1)) {
43987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
43988 }
43989 arg1 = reinterpret_cast< wxMenu * >(argp1);
43990 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
43991 if (!SWIG_IsOK(res2)) {
43992 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
43993 }
43994 arg2 = reinterpret_cast< wxWindow * >(argp2);
43995 {
43996 PyThreadState* __tstate = wxPyBeginAllowThreads();
43997 (arg1)->SetInvokingWindow(arg2);
43998 wxPyEndAllowThreads(__tstate);
43999 if (PyErr_Occurred()) SWIG_fail;
44000 }
44001 resultobj = SWIG_Py_Void();
44002 return resultobj;
44003 fail:
44004 return NULL;
44005 }
44006
44007
44008 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44009 PyObject *resultobj = 0;
44010 wxMenu *arg1 = (wxMenu *) 0 ;
44011 wxWindow *result = 0 ;
44012 void *argp1 = 0 ;
44013 int res1 = 0 ;
44014 PyObject *swig_obj[1] ;
44015
44016 if (!args) SWIG_fail;
44017 swig_obj[0] = args;
44018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44019 if (!SWIG_IsOK(res1)) {
44020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
44021 }
44022 arg1 = reinterpret_cast< wxMenu * >(argp1);
44023 {
44024 PyThreadState* __tstate = wxPyBeginAllowThreads();
44025 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
44026 wxPyEndAllowThreads(__tstate);
44027 if (PyErr_Occurred()) SWIG_fail;
44028 }
44029 {
44030 resultobj = wxPyMake_wxObject(result, 0);
44031 }
44032 return resultobj;
44033 fail:
44034 return NULL;
44035 }
44036
44037
44038 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44039 PyObject *resultobj = 0;
44040 wxMenu *arg1 = (wxMenu *) 0 ;
44041 long result;
44042 void *argp1 = 0 ;
44043 int res1 = 0 ;
44044 PyObject *swig_obj[1] ;
44045
44046 if (!args) SWIG_fail;
44047 swig_obj[0] = args;
44048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44049 if (!SWIG_IsOK(res1)) {
44050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44051 }
44052 arg1 = reinterpret_cast< wxMenu * >(argp1);
44053 {
44054 PyThreadState* __tstate = wxPyBeginAllowThreads();
44055 result = (long)((wxMenu const *)arg1)->GetStyle();
44056 wxPyEndAllowThreads(__tstate);
44057 if (PyErr_Occurred()) SWIG_fail;
44058 }
44059 resultobj = SWIG_From_long(static_cast< long >(result));
44060 return resultobj;
44061 fail:
44062 return NULL;
44063 }
44064
44065
44066 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44067 PyObject *resultobj = 0;
44068 wxMenu *arg1 = (wxMenu *) 0 ;
44069 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
44070 void *argp1 = 0 ;
44071 int res1 = 0 ;
44072 void *argp2 = 0 ;
44073 int res2 = 0 ;
44074 PyObject * obj0 = 0 ;
44075 PyObject * obj1 = 0 ;
44076 char * kwnames[] = {
44077 (char *) "self",(char *) "source", NULL
44078 };
44079
44080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
44081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44082 if (!SWIG_IsOK(res1)) {
44083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
44084 }
44085 arg1 = reinterpret_cast< wxMenu * >(argp1);
44086 if (obj1) {
44087 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44088 if (!SWIG_IsOK(res2)) {
44089 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44090 }
44091 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44092 }
44093 {
44094 PyThreadState* __tstate = wxPyBeginAllowThreads();
44095 (arg1)->UpdateUI(arg2);
44096 wxPyEndAllowThreads(__tstate);
44097 if (PyErr_Occurred()) SWIG_fail;
44098 }
44099 resultobj = SWIG_Py_Void();
44100 return resultobj;
44101 fail:
44102 return NULL;
44103 }
44104
44105
44106 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44107 PyObject *resultobj = 0;
44108 wxMenu *arg1 = (wxMenu *) 0 ;
44109 wxMenuBar *result = 0 ;
44110 void *argp1 = 0 ;
44111 int res1 = 0 ;
44112 PyObject *swig_obj[1] ;
44113
44114 if (!args) SWIG_fail;
44115 swig_obj[0] = args;
44116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44117 if (!SWIG_IsOK(res1)) {
44118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
44119 }
44120 arg1 = reinterpret_cast< wxMenu * >(argp1);
44121 {
44122 PyThreadState* __tstate = wxPyBeginAllowThreads();
44123 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
44124 wxPyEndAllowThreads(__tstate);
44125 if (PyErr_Occurred()) SWIG_fail;
44126 }
44127 {
44128 resultobj = wxPyMake_wxObject(result, (bool)0);
44129 }
44130 return resultobj;
44131 fail:
44132 return NULL;
44133 }
44134
44135
44136 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44137 PyObject *resultobj = 0;
44138 wxMenu *arg1 = (wxMenu *) 0 ;
44139 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
44140 void *argp1 = 0 ;
44141 int res1 = 0 ;
44142 void *argp2 = 0 ;
44143 int res2 = 0 ;
44144 PyObject * obj0 = 0 ;
44145 PyObject * obj1 = 0 ;
44146 char * kwnames[] = {
44147 (char *) "self",(char *) "menubar", NULL
44148 };
44149
44150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
44151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44152 if (!SWIG_IsOK(res1)) {
44153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
44154 }
44155 arg1 = reinterpret_cast< wxMenu * >(argp1);
44156 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
44157 if (!SWIG_IsOK(res2)) {
44158 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
44159 }
44160 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
44161 {
44162 PyThreadState* __tstate = wxPyBeginAllowThreads();
44163 (arg1)->Attach(arg2);
44164 wxPyEndAllowThreads(__tstate);
44165 if (PyErr_Occurred()) SWIG_fail;
44166 }
44167 resultobj = SWIG_Py_Void();
44168 return resultobj;
44169 fail:
44170 return NULL;
44171 }
44172
44173
44174 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44175 PyObject *resultobj = 0;
44176 wxMenu *arg1 = (wxMenu *) 0 ;
44177 void *argp1 = 0 ;
44178 int res1 = 0 ;
44179 PyObject *swig_obj[1] ;
44180
44181 if (!args) SWIG_fail;
44182 swig_obj[0] = args;
44183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44184 if (!SWIG_IsOK(res1)) {
44185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
44186 }
44187 arg1 = reinterpret_cast< wxMenu * >(argp1);
44188 {
44189 PyThreadState* __tstate = wxPyBeginAllowThreads();
44190 (arg1)->Detach();
44191 wxPyEndAllowThreads(__tstate);
44192 if (PyErr_Occurred()) SWIG_fail;
44193 }
44194 resultobj = SWIG_Py_Void();
44195 return resultobj;
44196 fail:
44197 return NULL;
44198 }
44199
44200
44201 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44202 PyObject *resultobj = 0;
44203 wxMenu *arg1 = (wxMenu *) 0 ;
44204 bool result;
44205 void *argp1 = 0 ;
44206 int res1 = 0 ;
44207 PyObject *swig_obj[1] ;
44208
44209 if (!args) SWIG_fail;
44210 swig_obj[0] = args;
44211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44212 if (!SWIG_IsOK(res1)) {
44213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
44214 }
44215 arg1 = reinterpret_cast< wxMenu * >(argp1);
44216 {
44217 PyThreadState* __tstate = wxPyBeginAllowThreads();
44218 result = (bool)((wxMenu const *)arg1)->IsAttached();
44219 wxPyEndAllowThreads(__tstate);
44220 if (PyErr_Occurred()) SWIG_fail;
44221 }
44222 {
44223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44224 }
44225 return resultobj;
44226 fail:
44227 return NULL;
44228 }
44229
44230
44231 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44232 PyObject *resultobj = 0;
44233 wxMenu *arg1 = (wxMenu *) 0 ;
44234 wxMenu *arg2 = (wxMenu *) 0 ;
44235 void *argp1 = 0 ;
44236 int res1 = 0 ;
44237 void *argp2 = 0 ;
44238 int res2 = 0 ;
44239 PyObject * obj0 = 0 ;
44240 PyObject * obj1 = 0 ;
44241 char * kwnames[] = {
44242 (char *) "self",(char *) "parent", NULL
44243 };
44244
44245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
44246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44247 if (!SWIG_IsOK(res1)) {
44248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
44249 }
44250 arg1 = reinterpret_cast< wxMenu * >(argp1);
44251 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44252 if (!SWIG_IsOK(res2)) {
44253 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
44254 }
44255 arg2 = reinterpret_cast< wxMenu * >(argp2);
44256 {
44257 PyThreadState* __tstate = wxPyBeginAllowThreads();
44258 (arg1)->SetParent(arg2);
44259 wxPyEndAllowThreads(__tstate);
44260 if (PyErr_Occurred()) SWIG_fail;
44261 }
44262 resultobj = SWIG_Py_Void();
44263 return resultobj;
44264 fail:
44265 return NULL;
44266 }
44267
44268
44269 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44270 PyObject *resultobj = 0;
44271 wxMenu *arg1 = (wxMenu *) 0 ;
44272 wxMenu *result = 0 ;
44273 void *argp1 = 0 ;
44274 int res1 = 0 ;
44275 PyObject *swig_obj[1] ;
44276
44277 if (!args) SWIG_fail;
44278 swig_obj[0] = args;
44279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44280 if (!SWIG_IsOK(res1)) {
44281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
44282 }
44283 arg1 = reinterpret_cast< wxMenu * >(argp1);
44284 {
44285 PyThreadState* __tstate = wxPyBeginAllowThreads();
44286 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
44287 wxPyEndAllowThreads(__tstate);
44288 if (PyErr_Occurred()) SWIG_fail;
44289 }
44290 {
44291 resultobj = wxPyMake_wxObject(result, 0);
44292 }
44293 return resultobj;
44294 fail:
44295 return NULL;
44296 }
44297
44298
44299 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44300 PyObject *obj;
44301 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44302 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
44303 return SWIG_Py_Void();
44304 }
44305
44306 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44307 return SWIG_Python_InitShadowInstance(args);
44308 }
44309
44310 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44311 PyObject *resultobj = 0;
44312 long arg1 = (long) 0 ;
44313 wxMenuBar *result = 0 ;
44314 long val1 ;
44315 int ecode1 = 0 ;
44316 PyObject * obj0 = 0 ;
44317 char * kwnames[] = {
44318 (char *) "style", NULL
44319 };
44320
44321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
44322 if (obj0) {
44323 ecode1 = SWIG_AsVal_long(obj0, &val1);
44324 if (!SWIG_IsOK(ecode1)) {
44325 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
44326 }
44327 arg1 = static_cast< long >(val1);
44328 }
44329 {
44330 if (!wxPyCheckForApp()) SWIG_fail;
44331 PyThreadState* __tstate = wxPyBeginAllowThreads();
44332 result = (wxMenuBar *)new wxMenuBar(arg1);
44333 wxPyEndAllowThreads(__tstate);
44334 if (PyErr_Occurred()) SWIG_fail;
44335 }
44336 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
44337 return resultobj;
44338 fail:
44339 return NULL;
44340 }
44341
44342
44343 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44344 PyObject *resultobj = 0;
44345 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44346 wxMenu *arg2 = (wxMenu *) 0 ;
44347 wxString *arg3 = 0 ;
44348 bool result;
44349 void *argp1 = 0 ;
44350 int res1 = 0 ;
44351 void *argp2 = 0 ;
44352 int res2 = 0 ;
44353 bool temp3 = false ;
44354 PyObject * obj0 = 0 ;
44355 PyObject * obj1 = 0 ;
44356 PyObject * obj2 = 0 ;
44357 char * kwnames[] = {
44358 (char *) "self",(char *) "menu",(char *) "title", NULL
44359 };
44360
44361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44363 if (!SWIG_IsOK(res1)) {
44364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44365 }
44366 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44367 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44368 if (!SWIG_IsOK(res2)) {
44369 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
44370 }
44371 arg2 = reinterpret_cast< wxMenu * >(argp2);
44372 {
44373 arg3 = wxString_in_helper(obj2);
44374 if (arg3 == NULL) SWIG_fail;
44375 temp3 = true;
44376 }
44377 {
44378 PyThreadState* __tstate = wxPyBeginAllowThreads();
44379 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
44380 wxPyEndAllowThreads(__tstate);
44381 if (PyErr_Occurred()) SWIG_fail;
44382 }
44383 {
44384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44385 }
44386 {
44387 if (temp3)
44388 delete arg3;
44389 }
44390 return resultobj;
44391 fail:
44392 {
44393 if (temp3)
44394 delete arg3;
44395 }
44396 return NULL;
44397 }
44398
44399
44400 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44401 PyObject *resultobj = 0;
44402 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44403 size_t arg2 ;
44404 wxMenu *arg3 = (wxMenu *) 0 ;
44405 wxString *arg4 = 0 ;
44406 bool result;
44407 void *argp1 = 0 ;
44408 int res1 = 0 ;
44409 size_t val2 ;
44410 int ecode2 = 0 ;
44411 void *argp3 = 0 ;
44412 int res3 = 0 ;
44413 bool temp4 = false ;
44414 PyObject * obj0 = 0 ;
44415 PyObject * obj1 = 0 ;
44416 PyObject * obj2 = 0 ;
44417 PyObject * obj3 = 0 ;
44418 char * kwnames[] = {
44419 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44420 };
44421
44422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44424 if (!SWIG_IsOK(res1)) {
44425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44426 }
44427 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44428 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44429 if (!SWIG_IsOK(ecode2)) {
44430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
44431 }
44432 arg2 = static_cast< size_t >(val2);
44433 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44434 if (!SWIG_IsOK(res3)) {
44435 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
44436 }
44437 arg3 = reinterpret_cast< wxMenu * >(argp3);
44438 {
44439 arg4 = wxString_in_helper(obj3);
44440 if (arg4 == NULL) SWIG_fail;
44441 temp4 = true;
44442 }
44443 {
44444 PyThreadState* __tstate = wxPyBeginAllowThreads();
44445 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
44446 wxPyEndAllowThreads(__tstate);
44447 if (PyErr_Occurred()) SWIG_fail;
44448 }
44449 {
44450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44451 }
44452 {
44453 if (temp4)
44454 delete arg4;
44455 }
44456 return resultobj;
44457 fail:
44458 {
44459 if (temp4)
44460 delete arg4;
44461 }
44462 return NULL;
44463 }
44464
44465
44466 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44467 PyObject *resultobj = 0;
44468 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44469 size_t result;
44470 void *argp1 = 0 ;
44471 int res1 = 0 ;
44472 PyObject *swig_obj[1] ;
44473
44474 if (!args) SWIG_fail;
44475 swig_obj[0] = args;
44476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44477 if (!SWIG_IsOK(res1)) {
44478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44479 }
44480 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44481 {
44482 PyThreadState* __tstate = wxPyBeginAllowThreads();
44483 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
44484 wxPyEndAllowThreads(__tstate);
44485 if (PyErr_Occurred()) SWIG_fail;
44486 }
44487 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
44488 return resultobj;
44489 fail:
44490 return NULL;
44491 }
44492
44493
44494 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44495 PyObject *resultobj = 0;
44496 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44497 size_t arg2 ;
44498 wxMenu *result = 0 ;
44499 void *argp1 = 0 ;
44500 int res1 = 0 ;
44501 size_t val2 ;
44502 int ecode2 = 0 ;
44503 PyObject * obj0 = 0 ;
44504 PyObject * obj1 = 0 ;
44505 char * kwnames[] = {
44506 (char *) "self",(char *) "pos", NULL
44507 };
44508
44509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44511 if (!SWIG_IsOK(res1)) {
44512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44513 }
44514 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44515 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44516 if (!SWIG_IsOK(ecode2)) {
44517 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
44518 }
44519 arg2 = static_cast< size_t >(val2);
44520 {
44521 PyThreadState* __tstate = wxPyBeginAllowThreads();
44522 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
44523 wxPyEndAllowThreads(__tstate);
44524 if (PyErr_Occurred()) SWIG_fail;
44525 }
44526 {
44527 resultobj = wxPyMake_wxObject(result, 0);
44528 }
44529 return resultobj;
44530 fail:
44531 return NULL;
44532 }
44533
44534
44535 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44536 PyObject *resultobj = 0;
44537 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44538 size_t arg2 ;
44539 wxMenu *arg3 = (wxMenu *) 0 ;
44540 wxString *arg4 = 0 ;
44541 wxMenu *result = 0 ;
44542 void *argp1 = 0 ;
44543 int res1 = 0 ;
44544 size_t val2 ;
44545 int ecode2 = 0 ;
44546 void *argp3 = 0 ;
44547 int res3 = 0 ;
44548 bool temp4 = false ;
44549 PyObject * obj0 = 0 ;
44550 PyObject * obj1 = 0 ;
44551 PyObject * obj2 = 0 ;
44552 PyObject * obj3 = 0 ;
44553 char * kwnames[] = {
44554 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44555 };
44556
44557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44559 if (!SWIG_IsOK(res1)) {
44560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44561 }
44562 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44563 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44564 if (!SWIG_IsOK(ecode2)) {
44565 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
44566 }
44567 arg2 = static_cast< size_t >(val2);
44568 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44569 if (!SWIG_IsOK(res3)) {
44570 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
44571 }
44572 arg3 = reinterpret_cast< wxMenu * >(argp3);
44573 {
44574 arg4 = wxString_in_helper(obj3);
44575 if (arg4 == NULL) SWIG_fail;
44576 temp4 = true;
44577 }
44578 {
44579 PyThreadState* __tstate = wxPyBeginAllowThreads();
44580 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
44581 wxPyEndAllowThreads(__tstate);
44582 if (PyErr_Occurred()) SWIG_fail;
44583 }
44584 {
44585 resultobj = wxPyMake_wxObject(result, 0);
44586 }
44587 {
44588 if (temp4)
44589 delete arg4;
44590 }
44591 return resultobj;
44592 fail:
44593 {
44594 if (temp4)
44595 delete arg4;
44596 }
44597 return NULL;
44598 }
44599
44600
44601 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44602 PyObject *resultobj = 0;
44603 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44604 size_t arg2 ;
44605 wxMenu *result = 0 ;
44606 void *argp1 = 0 ;
44607 int res1 = 0 ;
44608 size_t val2 ;
44609 int ecode2 = 0 ;
44610 PyObject * obj0 = 0 ;
44611 PyObject * obj1 = 0 ;
44612 char * kwnames[] = {
44613 (char *) "self",(char *) "pos", NULL
44614 };
44615
44616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
44617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44618 if (!SWIG_IsOK(res1)) {
44619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44620 }
44621 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44622 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44623 if (!SWIG_IsOK(ecode2)) {
44624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
44625 }
44626 arg2 = static_cast< size_t >(val2);
44627 {
44628 PyThreadState* __tstate = wxPyBeginAllowThreads();
44629 result = (wxMenu *)(arg1)->Remove(arg2);
44630 wxPyEndAllowThreads(__tstate);
44631 if (PyErr_Occurred()) SWIG_fail;
44632 }
44633 {
44634 resultobj = wxPyMake_wxObject(result, 0);
44635 }
44636 return resultobj;
44637 fail:
44638 return NULL;
44639 }
44640
44641
44642 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44643 PyObject *resultobj = 0;
44644 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44645 size_t arg2 ;
44646 bool arg3 ;
44647 void *argp1 = 0 ;
44648 int res1 = 0 ;
44649 size_t val2 ;
44650 int ecode2 = 0 ;
44651 bool val3 ;
44652 int ecode3 = 0 ;
44653 PyObject * obj0 = 0 ;
44654 PyObject * obj1 = 0 ;
44655 PyObject * obj2 = 0 ;
44656 char * kwnames[] = {
44657 (char *) "self",(char *) "pos",(char *) "enable", NULL
44658 };
44659
44660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44662 if (!SWIG_IsOK(res1)) {
44663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44664 }
44665 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44666 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44667 if (!SWIG_IsOK(ecode2)) {
44668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
44669 }
44670 arg2 = static_cast< size_t >(val2);
44671 ecode3 = SWIG_AsVal_bool(obj2, &val3);
44672 if (!SWIG_IsOK(ecode3)) {
44673 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
44674 }
44675 arg3 = static_cast< bool >(val3);
44676 {
44677 PyThreadState* __tstate = wxPyBeginAllowThreads();
44678 (arg1)->EnableTop(arg2,arg3);
44679 wxPyEndAllowThreads(__tstate);
44680 if (PyErr_Occurred()) SWIG_fail;
44681 }
44682 resultobj = SWIG_Py_Void();
44683 return resultobj;
44684 fail:
44685 return NULL;
44686 }
44687
44688
44689 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44690 PyObject *resultobj = 0;
44691 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44692 size_t arg2 ;
44693 bool result;
44694 void *argp1 = 0 ;
44695 int res1 = 0 ;
44696 size_t val2 ;
44697 int ecode2 = 0 ;
44698 PyObject * obj0 = 0 ;
44699 PyObject * obj1 = 0 ;
44700 char * kwnames[] = {
44701 (char *) "self",(char *) "pos", NULL
44702 };
44703
44704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
44705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44706 if (!SWIG_IsOK(res1)) {
44707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44708 }
44709 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44710 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44711 if (!SWIG_IsOK(ecode2)) {
44712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
44713 }
44714 arg2 = static_cast< size_t >(val2);
44715 {
44716 PyThreadState* __tstate = wxPyBeginAllowThreads();
44717 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
44718 wxPyEndAllowThreads(__tstate);
44719 if (PyErr_Occurred()) SWIG_fail;
44720 }
44721 {
44722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44723 }
44724 return resultobj;
44725 fail:
44726 return NULL;
44727 }
44728
44729
44730 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44731 PyObject *resultobj = 0;
44732 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44733 size_t arg2 ;
44734 wxString *arg3 = 0 ;
44735 void *argp1 = 0 ;
44736 int res1 = 0 ;
44737 size_t val2 ;
44738 int ecode2 = 0 ;
44739 bool temp3 = false ;
44740 PyObject * obj0 = 0 ;
44741 PyObject * obj1 = 0 ;
44742 PyObject * obj2 = 0 ;
44743 char * kwnames[] = {
44744 (char *) "self",(char *) "pos",(char *) "label", NULL
44745 };
44746
44747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44749 if (!SWIG_IsOK(res1)) {
44750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44751 }
44752 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44753 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44754 if (!SWIG_IsOK(ecode2)) {
44755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
44756 }
44757 arg2 = static_cast< size_t >(val2);
44758 {
44759 arg3 = wxString_in_helper(obj2);
44760 if (arg3 == NULL) SWIG_fail;
44761 temp3 = true;
44762 }
44763 {
44764 PyThreadState* __tstate = wxPyBeginAllowThreads();
44765 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
44766 wxPyEndAllowThreads(__tstate);
44767 if (PyErr_Occurred()) SWIG_fail;
44768 }
44769 resultobj = SWIG_Py_Void();
44770 {
44771 if (temp3)
44772 delete arg3;
44773 }
44774 return resultobj;
44775 fail:
44776 {
44777 if (temp3)
44778 delete arg3;
44779 }
44780 return NULL;
44781 }
44782
44783
44784 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44785 PyObject *resultobj = 0;
44786 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44787 size_t arg2 ;
44788 wxString result;
44789 void *argp1 = 0 ;
44790 int res1 = 0 ;
44791 size_t val2 ;
44792 int ecode2 = 0 ;
44793 PyObject * obj0 = 0 ;
44794 PyObject * obj1 = 0 ;
44795 char * kwnames[] = {
44796 (char *) "self",(char *) "pos", NULL
44797 };
44798
44799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
44800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44801 if (!SWIG_IsOK(res1)) {
44802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44803 }
44804 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44805 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44806 if (!SWIG_IsOK(ecode2)) {
44807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
44808 }
44809 arg2 = static_cast< size_t >(val2);
44810 {
44811 PyThreadState* __tstate = wxPyBeginAllowThreads();
44812 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
44813 wxPyEndAllowThreads(__tstate);
44814 if (PyErr_Occurred()) SWIG_fail;
44815 }
44816 {
44817 #if wxUSE_UNICODE
44818 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44819 #else
44820 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44821 #endif
44822 }
44823 return resultobj;
44824 fail:
44825 return NULL;
44826 }
44827
44828
44829 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44830 PyObject *resultobj = 0;
44831 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44832 wxString *arg2 = 0 ;
44833 wxString *arg3 = 0 ;
44834 int result;
44835 void *argp1 = 0 ;
44836 int res1 = 0 ;
44837 bool temp2 = false ;
44838 bool temp3 = false ;
44839 PyObject * obj0 = 0 ;
44840 PyObject * obj1 = 0 ;
44841 PyObject * obj2 = 0 ;
44842 char * kwnames[] = {
44843 (char *) "self",(char *) "menu",(char *) "item", NULL
44844 };
44845
44846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44848 if (!SWIG_IsOK(res1)) {
44849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44850 }
44851 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44852 {
44853 arg2 = wxString_in_helper(obj1);
44854 if (arg2 == NULL) SWIG_fail;
44855 temp2 = true;
44856 }
44857 {
44858 arg3 = wxString_in_helper(obj2);
44859 if (arg3 == NULL) SWIG_fail;
44860 temp3 = true;
44861 }
44862 {
44863 PyThreadState* __tstate = wxPyBeginAllowThreads();
44864 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
44865 wxPyEndAllowThreads(__tstate);
44866 if (PyErr_Occurred()) SWIG_fail;
44867 }
44868 resultobj = SWIG_From_int(static_cast< int >(result));
44869 {
44870 if (temp2)
44871 delete arg2;
44872 }
44873 {
44874 if (temp3)
44875 delete arg3;
44876 }
44877 return resultobj;
44878 fail:
44879 {
44880 if (temp2)
44881 delete arg2;
44882 }
44883 {
44884 if (temp3)
44885 delete arg3;
44886 }
44887 return NULL;
44888 }
44889
44890
44891 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44892 PyObject *resultobj = 0;
44893 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44894 int arg2 ;
44895 wxMenuItem *result = 0 ;
44896 void *argp1 = 0 ;
44897 int res1 = 0 ;
44898 int val2 ;
44899 int ecode2 = 0 ;
44900 PyObject * obj0 = 0 ;
44901 PyObject * obj1 = 0 ;
44902 char * kwnames[] = {
44903 (char *) "self",(char *) "id", NULL
44904 };
44905
44906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
44907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44908 if (!SWIG_IsOK(res1)) {
44909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44910 }
44911 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44912 ecode2 = SWIG_AsVal_int(obj1, &val2);
44913 if (!SWIG_IsOK(ecode2)) {
44914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
44915 }
44916 arg2 = static_cast< int >(val2);
44917 {
44918 PyThreadState* __tstate = wxPyBeginAllowThreads();
44919 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
44920 wxPyEndAllowThreads(__tstate);
44921 if (PyErr_Occurred()) SWIG_fail;
44922 }
44923 {
44924 resultobj = wxPyMake_wxObject(result, (bool)0);
44925 }
44926 return resultobj;
44927 fail:
44928 return NULL;
44929 }
44930
44931
44932 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44933 PyObject *resultobj = 0;
44934 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44935 wxString *arg2 = 0 ;
44936 int result;
44937 void *argp1 = 0 ;
44938 int res1 = 0 ;
44939 bool temp2 = false ;
44940 PyObject * obj0 = 0 ;
44941 PyObject * obj1 = 0 ;
44942 char * kwnames[] = {
44943 (char *) "self",(char *) "title", NULL
44944 };
44945
44946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44948 if (!SWIG_IsOK(res1)) {
44949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44950 }
44951 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44952 {
44953 arg2 = wxString_in_helper(obj1);
44954 if (arg2 == NULL) SWIG_fail;
44955 temp2 = true;
44956 }
44957 {
44958 PyThreadState* __tstate = wxPyBeginAllowThreads();
44959 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
44960 wxPyEndAllowThreads(__tstate);
44961 if (PyErr_Occurred()) SWIG_fail;
44962 }
44963 resultobj = SWIG_From_int(static_cast< int >(result));
44964 {
44965 if (temp2)
44966 delete arg2;
44967 }
44968 return resultobj;
44969 fail:
44970 {
44971 if (temp2)
44972 delete arg2;
44973 }
44974 return NULL;
44975 }
44976
44977
44978 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44979 PyObject *resultobj = 0;
44980 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44981 int arg2 ;
44982 bool arg3 ;
44983 void *argp1 = 0 ;
44984 int res1 = 0 ;
44985 int val2 ;
44986 int ecode2 = 0 ;
44987 bool val3 ;
44988 int ecode3 = 0 ;
44989 PyObject * obj0 = 0 ;
44990 PyObject * obj1 = 0 ;
44991 PyObject * obj2 = 0 ;
44992 char * kwnames[] = {
44993 (char *) "self",(char *) "id",(char *) "enable", NULL
44994 };
44995
44996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44998 if (!SWIG_IsOK(res1)) {
44999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45000 }
45001 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45002 ecode2 = SWIG_AsVal_int(obj1, &val2);
45003 if (!SWIG_IsOK(ecode2)) {
45004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
45005 }
45006 arg2 = static_cast< int >(val2);
45007 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45008 if (!SWIG_IsOK(ecode3)) {
45009 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
45010 }
45011 arg3 = static_cast< bool >(val3);
45012 {
45013 PyThreadState* __tstate = wxPyBeginAllowThreads();
45014 (arg1)->Enable(arg2,arg3);
45015 wxPyEndAllowThreads(__tstate);
45016 if (PyErr_Occurred()) SWIG_fail;
45017 }
45018 resultobj = SWIG_Py_Void();
45019 return resultobj;
45020 fail:
45021 return NULL;
45022 }
45023
45024
45025 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45026 PyObject *resultobj = 0;
45027 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45028 int arg2 ;
45029 bool arg3 ;
45030 void *argp1 = 0 ;
45031 int res1 = 0 ;
45032 int val2 ;
45033 int ecode2 = 0 ;
45034 bool val3 ;
45035 int ecode3 = 0 ;
45036 PyObject * obj0 = 0 ;
45037 PyObject * obj1 = 0 ;
45038 PyObject * obj2 = 0 ;
45039 char * kwnames[] = {
45040 (char *) "self",(char *) "id",(char *) "check", NULL
45041 };
45042
45043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45045 if (!SWIG_IsOK(res1)) {
45046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45047 }
45048 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45049 ecode2 = SWIG_AsVal_int(obj1, &val2);
45050 if (!SWIG_IsOK(ecode2)) {
45051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
45052 }
45053 arg2 = static_cast< int >(val2);
45054 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45055 if (!SWIG_IsOK(ecode3)) {
45056 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
45057 }
45058 arg3 = static_cast< bool >(val3);
45059 {
45060 PyThreadState* __tstate = wxPyBeginAllowThreads();
45061 (arg1)->Check(arg2,arg3);
45062 wxPyEndAllowThreads(__tstate);
45063 if (PyErr_Occurred()) SWIG_fail;
45064 }
45065 resultobj = SWIG_Py_Void();
45066 return resultobj;
45067 fail:
45068 return NULL;
45069 }
45070
45071
45072 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45073 PyObject *resultobj = 0;
45074 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45075 int arg2 ;
45076 bool result;
45077 void *argp1 = 0 ;
45078 int res1 = 0 ;
45079 int val2 ;
45080 int ecode2 = 0 ;
45081 PyObject * obj0 = 0 ;
45082 PyObject * obj1 = 0 ;
45083 char * kwnames[] = {
45084 (char *) "self",(char *) "id", NULL
45085 };
45086
45087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
45088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45089 if (!SWIG_IsOK(res1)) {
45090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45091 }
45092 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45093 ecode2 = SWIG_AsVal_int(obj1, &val2);
45094 if (!SWIG_IsOK(ecode2)) {
45095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
45096 }
45097 arg2 = static_cast< int >(val2);
45098 {
45099 PyThreadState* __tstate = wxPyBeginAllowThreads();
45100 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
45101 wxPyEndAllowThreads(__tstate);
45102 if (PyErr_Occurred()) SWIG_fail;
45103 }
45104 {
45105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45106 }
45107 return resultobj;
45108 fail:
45109 return NULL;
45110 }
45111
45112
45113 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45114 PyObject *resultobj = 0;
45115 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45116 int arg2 ;
45117 bool result;
45118 void *argp1 = 0 ;
45119 int res1 = 0 ;
45120 int val2 ;
45121 int ecode2 = 0 ;
45122 PyObject * obj0 = 0 ;
45123 PyObject * obj1 = 0 ;
45124 char * kwnames[] = {
45125 (char *) "self",(char *) "id", NULL
45126 };
45127
45128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
45129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45130 if (!SWIG_IsOK(res1)) {
45131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45132 }
45133 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45134 ecode2 = SWIG_AsVal_int(obj1, &val2);
45135 if (!SWIG_IsOK(ecode2)) {
45136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
45137 }
45138 arg2 = static_cast< int >(val2);
45139 {
45140 PyThreadState* __tstate = wxPyBeginAllowThreads();
45141 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
45142 wxPyEndAllowThreads(__tstate);
45143 if (PyErr_Occurred()) SWIG_fail;
45144 }
45145 {
45146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45147 }
45148 return resultobj;
45149 fail:
45150 return NULL;
45151 }
45152
45153
45154 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45155 PyObject *resultobj = 0;
45156 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45157 int arg2 ;
45158 wxString *arg3 = 0 ;
45159 void *argp1 = 0 ;
45160 int res1 = 0 ;
45161 int val2 ;
45162 int ecode2 = 0 ;
45163 bool temp3 = false ;
45164 PyObject * obj0 = 0 ;
45165 PyObject * obj1 = 0 ;
45166 PyObject * obj2 = 0 ;
45167 char * kwnames[] = {
45168 (char *) "self",(char *) "id",(char *) "label", NULL
45169 };
45170
45171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45173 if (!SWIG_IsOK(res1)) {
45174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45175 }
45176 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45177 ecode2 = SWIG_AsVal_int(obj1, &val2);
45178 if (!SWIG_IsOK(ecode2)) {
45179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
45180 }
45181 arg2 = static_cast< int >(val2);
45182 {
45183 arg3 = wxString_in_helper(obj2);
45184 if (arg3 == NULL) SWIG_fail;
45185 temp3 = true;
45186 }
45187 {
45188 PyThreadState* __tstate = wxPyBeginAllowThreads();
45189 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
45190 wxPyEndAllowThreads(__tstate);
45191 if (PyErr_Occurred()) SWIG_fail;
45192 }
45193 resultobj = SWIG_Py_Void();
45194 {
45195 if (temp3)
45196 delete arg3;
45197 }
45198 return resultobj;
45199 fail:
45200 {
45201 if (temp3)
45202 delete arg3;
45203 }
45204 return NULL;
45205 }
45206
45207
45208 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45209 PyObject *resultobj = 0;
45210 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45211 int arg2 ;
45212 wxString result;
45213 void *argp1 = 0 ;
45214 int res1 = 0 ;
45215 int val2 ;
45216 int ecode2 = 0 ;
45217 PyObject * obj0 = 0 ;
45218 PyObject * obj1 = 0 ;
45219 char * kwnames[] = {
45220 (char *) "self",(char *) "id", NULL
45221 };
45222
45223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
45224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45225 if (!SWIG_IsOK(res1)) {
45226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45227 }
45228 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45229 ecode2 = SWIG_AsVal_int(obj1, &val2);
45230 if (!SWIG_IsOK(ecode2)) {
45231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
45232 }
45233 arg2 = static_cast< int >(val2);
45234 {
45235 PyThreadState* __tstate = wxPyBeginAllowThreads();
45236 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
45237 wxPyEndAllowThreads(__tstate);
45238 if (PyErr_Occurred()) SWIG_fail;
45239 }
45240 {
45241 #if wxUSE_UNICODE
45242 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45243 #else
45244 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45245 #endif
45246 }
45247 return resultobj;
45248 fail:
45249 return NULL;
45250 }
45251
45252
45253 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45254 PyObject *resultobj = 0;
45255 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45256 int arg2 ;
45257 wxString *arg3 = 0 ;
45258 void *argp1 = 0 ;
45259 int res1 = 0 ;
45260 int val2 ;
45261 int ecode2 = 0 ;
45262 bool temp3 = false ;
45263 PyObject * obj0 = 0 ;
45264 PyObject * obj1 = 0 ;
45265 PyObject * obj2 = 0 ;
45266 char * kwnames[] = {
45267 (char *) "self",(char *) "id",(char *) "helpString", NULL
45268 };
45269
45270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45272 if (!SWIG_IsOK(res1)) {
45273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45274 }
45275 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45276 ecode2 = SWIG_AsVal_int(obj1, &val2);
45277 if (!SWIG_IsOK(ecode2)) {
45278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
45279 }
45280 arg2 = static_cast< int >(val2);
45281 {
45282 arg3 = wxString_in_helper(obj2);
45283 if (arg3 == NULL) SWIG_fail;
45284 temp3 = true;
45285 }
45286 {
45287 PyThreadState* __tstate = wxPyBeginAllowThreads();
45288 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
45289 wxPyEndAllowThreads(__tstate);
45290 if (PyErr_Occurred()) SWIG_fail;
45291 }
45292 resultobj = SWIG_Py_Void();
45293 {
45294 if (temp3)
45295 delete arg3;
45296 }
45297 return resultobj;
45298 fail:
45299 {
45300 if (temp3)
45301 delete arg3;
45302 }
45303 return NULL;
45304 }
45305
45306
45307 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45308 PyObject *resultobj = 0;
45309 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45310 int arg2 ;
45311 wxString result;
45312 void *argp1 = 0 ;
45313 int res1 = 0 ;
45314 int val2 ;
45315 int ecode2 = 0 ;
45316 PyObject * obj0 = 0 ;
45317 PyObject * obj1 = 0 ;
45318 char * kwnames[] = {
45319 (char *) "self",(char *) "id", NULL
45320 };
45321
45322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
45323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45324 if (!SWIG_IsOK(res1)) {
45325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45326 }
45327 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45328 ecode2 = SWIG_AsVal_int(obj1, &val2);
45329 if (!SWIG_IsOK(ecode2)) {
45330 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
45331 }
45332 arg2 = static_cast< int >(val2);
45333 {
45334 PyThreadState* __tstate = wxPyBeginAllowThreads();
45335 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
45336 wxPyEndAllowThreads(__tstate);
45337 if (PyErr_Occurred()) SWIG_fail;
45338 }
45339 {
45340 #if wxUSE_UNICODE
45341 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45342 #else
45343 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45344 #endif
45345 }
45346 return resultobj;
45347 fail:
45348 return NULL;
45349 }
45350
45351
45352 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45353 PyObject *resultobj = 0;
45354 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45355 wxFrame *result = 0 ;
45356 void *argp1 = 0 ;
45357 int res1 = 0 ;
45358 PyObject *swig_obj[1] ;
45359
45360 if (!args) SWIG_fail;
45361 swig_obj[0] = args;
45362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45363 if (!SWIG_IsOK(res1)) {
45364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45365 }
45366 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45367 {
45368 PyThreadState* __tstate = wxPyBeginAllowThreads();
45369 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
45370 wxPyEndAllowThreads(__tstate);
45371 if (PyErr_Occurred()) SWIG_fail;
45372 }
45373 {
45374 resultobj = wxPyMake_wxObject(result, (bool)0);
45375 }
45376 return resultobj;
45377 fail:
45378 return NULL;
45379 }
45380
45381
45382 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45383 PyObject *resultobj = 0;
45384 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45385 bool result;
45386 void *argp1 = 0 ;
45387 int res1 = 0 ;
45388 PyObject *swig_obj[1] ;
45389
45390 if (!args) SWIG_fail;
45391 swig_obj[0] = args;
45392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45393 if (!SWIG_IsOK(res1)) {
45394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45395 }
45396 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45397 {
45398 PyThreadState* __tstate = wxPyBeginAllowThreads();
45399 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
45400 wxPyEndAllowThreads(__tstate);
45401 if (PyErr_Occurred()) SWIG_fail;
45402 }
45403 {
45404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45405 }
45406 return resultobj;
45407 fail:
45408 return NULL;
45409 }
45410
45411
45412 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45413 PyObject *resultobj = 0;
45414 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45415 wxFrame *arg2 = (wxFrame *) 0 ;
45416 void *argp1 = 0 ;
45417 int res1 = 0 ;
45418 void *argp2 = 0 ;
45419 int res2 = 0 ;
45420 PyObject * obj0 = 0 ;
45421 PyObject * obj1 = 0 ;
45422 char * kwnames[] = {
45423 (char *) "self",(char *) "frame", NULL
45424 };
45425
45426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
45427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45428 if (!SWIG_IsOK(res1)) {
45429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45430 }
45431 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45432 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
45433 if (!SWIG_IsOK(res2)) {
45434 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
45435 }
45436 arg2 = reinterpret_cast< wxFrame * >(argp2);
45437 {
45438 PyThreadState* __tstate = wxPyBeginAllowThreads();
45439 (arg1)->Attach(arg2);
45440 wxPyEndAllowThreads(__tstate);
45441 if (PyErr_Occurred()) SWIG_fail;
45442 }
45443 resultobj = SWIG_Py_Void();
45444 return resultobj;
45445 fail:
45446 return NULL;
45447 }
45448
45449
45450 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45451 PyObject *resultobj = 0;
45452 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45453 void *argp1 = 0 ;
45454 int res1 = 0 ;
45455 PyObject *swig_obj[1] ;
45456
45457 if (!args) SWIG_fail;
45458 swig_obj[0] = args;
45459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45460 if (!SWIG_IsOK(res1)) {
45461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45462 }
45463 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45464 {
45465 PyThreadState* __tstate = wxPyBeginAllowThreads();
45466 (arg1)->Detach();
45467 wxPyEndAllowThreads(__tstate);
45468 if (PyErr_Occurred()) SWIG_fail;
45469 }
45470 resultobj = SWIG_Py_Void();
45471 return resultobj;
45472 fail:
45473 return NULL;
45474 }
45475
45476
45477 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45478 PyObject *resultobj = 0;
45479 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45480 void *argp1 = 0 ;
45481 int res1 = 0 ;
45482 PyObject *swig_obj[1] ;
45483
45484 if (!args) SWIG_fail;
45485 swig_obj[0] = args;
45486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45487 if (!SWIG_IsOK(res1)) {
45488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45489 }
45490 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45491 {
45492 PyThreadState* __tstate = wxPyBeginAllowThreads();
45493 (arg1)->UpdateMenus();
45494 wxPyEndAllowThreads(__tstate);
45495 if (PyErr_Occurred()) SWIG_fail;
45496 }
45497 resultobj = SWIG_Py_Void();
45498 return resultobj;
45499 fail:
45500 return NULL;
45501 }
45502
45503
45504 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45505 PyObject *resultobj = 0;
45506 bool arg1 ;
45507 bool val1 ;
45508 int ecode1 = 0 ;
45509 PyObject * obj0 = 0 ;
45510 char * kwnames[] = {
45511 (char *) "enable", NULL
45512 };
45513
45514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
45515 ecode1 = SWIG_AsVal_bool(obj0, &val1);
45516 if (!SWIG_IsOK(ecode1)) {
45517 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
45518 }
45519 arg1 = static_cast< bool >(val1);
45520 {
45521 PyThreadState* __tstate = wxPyBeginAllowThreads();
45522 wxMenuBar_SetAutoWindowMenu(arg1);
45523 wxPyEndAllowThreads(__tstate);
45524 if (PyErr_Occurred()) SWIG_fail;
45525 }
45526 resultobj = SWIG_Py_Void();
45527 return resultobj;
45528 fail:
45529 return NULL;
45530 }
45531
45532
45533 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45534 PyObject *resultobj = 0;
45535 bool result;
45536
45537 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
45538 {
45539 PyThreadState* __tstate = wxPyBeginAllowThreads();
45540 result = (bool)wxMenuBar_GetAutoWindowMenu();
45541 wxPyEndAllowThreads(__tstate);
45542 if (PyErr_Occurred()) SWIG_fail;
45543 }
45544 {
45545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45546 }
45547 return resultobj;
45548 fail:
45549 return NULL;
45550 }
45551
45552
45553 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45554 PyObject *obj;
45555 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45556 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
45557 return SWIG_Py_Void();
45558 }
45559
45560 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45561 return SWIG_Python_InitShadowInstance(args);
45562 }
45563
45564 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45565 PyObject *resultobj = 0;
45566 wxMenu *arg1 = (wxMenu *) NULL ;
45567 int arg2 = (int) wxID_ANY ;
45568 wxString const &arg3_defvalue = wxPyEmptyString ;
45569 wxString *arg3 = (wxString *) &arg3_defvalue ;
45570 wxString const &arg4_defvalue = wxPyEmptyString ;
45571 wxString *arg4 = (wxString *) &arg4_defvalue ;
45572 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
45573 wxMenu *arg6 = (wxMenu *) NULL ;
45574 wxMenuItem *result = 0 ;
45575 void *argp1 = 0 ;
45576 int res1 = 0 ;
45577 int val2 ;
45578 int ecode2 = 0 ;
45579 bool temp3 = false ;
45580 bool temp4 = false ;
45581 int val5 ;
45582 int ecode5 = 0 ;
45583 void *argp6 = 0 ;
45584 int res6 = 0 ;
45585 PyObject * obj0 = 0 ;
45586 PyObject * obj1 = 0 ;
45587 PyObject * obj2 = 0 ;
45588 PyObject * obj3 = 0 ;
45589 PyObject * obj4 = 0 ;
45590 PyObject * obj5 = 0 ;
45591 char * kwnames[] = {
45592 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
45593 };
45594
45595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45596 if (obj0) {
45597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45598 if (!SWIG_IsOK(res1)) {
45599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
45600 }
45601 arg1 = reinterpret_cast< wxMenu * >(argp1);
45602 }
45603 if (obj1) {
45604 ecode2 = SWIG_AsVal_int(obj1, &val2);
45605 if (!SWIG_IsOK(ecode2)) {
45606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
45607 }
45608 arg2 = static_cast< int >(val2);
45609 }
45610 if (obj2) {
45611 {
45612 arg3 = wxString_in_helper(obj2);
45613 if (arg3 == NULL) SWIG_fail;
45614 temp3 = true;
45615 }
45616 }
45617 if (obj3) {
45618 {
45619 arg4 = wxString_in_helper(obj3);
45620 if (arg4 == NULL) SWIG_fail;
45621 temp4 = true;
45622 }
45623 }
45624 if (obj4) {
45625 ecode5 = SWIG_AsVal_int(obj4, &val5);
45626 if (!SWIG_IsOK(ecode5)) {
45627 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
45628 }
45629 arg5 = static_cast< wxItemKind >(val5);
45630 }
45631 if (obj5) {
45632 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
45633 if (!SWIG_IsOK(res6)) {
45634 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
45635 }
45636 arg6 = reinterpret_cast< wxMenu * >(argp6);
45637 }
45638 {
45639 PyThreadState* __tstate = wxPyBeginAllowThreads();
45640 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
45641 wxPyEndAllowThreads(__tstate);
45642 if (PyErr_Occurred()) SWIG_fail;
45643 }
45644 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_NEW | 0 );
45645 {
45646 if (temp3)
45647 delete arg3;
45648 }
45649 {
45650 if (temp4)
45651 delete arg4;
45652 }
45653 return resultobj;
45654 fail:
45655 {
45656 if (temp3)
45657 delete arg3;
45658 }
45659 {
45660 if (temp4)
45661 delete arg4;
45662 }
45663 return NULL;
45664 }
45665
45666
45667 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45668 PyObject *resultobj = 0;
45669 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45670 void *argp1 = 0 ;
45671 int res1 = 0 ;
45672 PyObject *swig_obj[1] ;
45673
45674 if (!args) SWIG_fail;
45675 swig_obj[0] = args;
45676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
45677 if (!SWIG_IsOK(res1)) {
45678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45679 }
45680 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45681 {
45682 PyThreadState* __tstate = wxPyBeginAllowThreads();
45683 delete arg1;
45684
45685 wxPyEndAllowThreads(__tstate);
45686 if (PyErr_Occurred()) SWIG_fail;
45687 }
45688 resultobj = SWIG_Py_Void();
45689 return resultobj;
45690 fail:
45691 return NULL;
45692 }
45693
45694
45695 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45696 PyObject *resultobj = 0;
45697 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45698 wxMenu *result = 0 ;
45699 void *argp1 = 0 ;
45700 int res1 = 0 ;
45701 PyObject *swig_obj[1] ;
45702
45703 if (!args) SWIG_fail;
45704 swig_obj[0] = args;
45705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45706 if (!SWIG_IsOK(res1)) {
45707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45708 }
45709 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45710 {
45711 PyThreadState* __tstate = wxPyBeginAllowThreads();
45712 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
45713 wxPyEndAllowThreads(__tstate);
45714 if (PyErr_Occurred()) SWIG_fail;
45715 }
45716 {
45717 resultobj = wxPyMake_wxObject(result, 0);
45718 }
45719 return resultobj;
45720 fail:
45721 return NULL;
45722 }
45723
45724
45725 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45726 PyObject *resultobj = 0;
45727 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45728 wxMenu *arg2 = (wxMenu *) 0 ;
45729 void *argp1 = 0 ;
45730 int res1 = 0 ;
45731 void *argp2 = 0 ;
45732 int res2 = 0 ;
45733 PyObject * obj0 = 0 ;
45734 PyObject * obj1 = 0 ;
45735 char * kwnames[] = {
45736 (char *) "self",(char *) "menu", NULL
45737 };
45738
45739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45741 if (!SWIG_IsOK(res1)) {
45742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45743 }
45744 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45745 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
45746 if (!SWIG_IsOK(res2)) {
45747 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
45748 }
45749 arg2 = reinterpret_cast< wxMenu * >(argp2);
45750 {
45751 PyThreadState* __tstate = wxPyBeginAllowThreads();
45752 (arg1)->SetMenu(arg2);
45753 wxPyEndAllowThreads(__tstate);
45754 if (PyErr_Occurred()) SWIG_fail;
45755 }
45756 resultobj = SWIG_Py_Void();
45757 return resultobj;
45758 fail:
45759 return NULL;
45760 }
45761
45762
45763 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45764 PyObject *resultobj = 0;
45765 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45766 int arg2 ;
45767 void *argp1 = 0 ;
45768 int res1 = 0 ;
45769 int val2 ;
45770 int ecode2 = 0 ;
45771 PyObject * obj0 = 0 ;
45772 PyObject * obj1 = 0 ;
45773 char * kwnames[] = {
45774 (char *) "self",(char *) "id", NULL
45775 };
45776
45777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
45778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45779 if (!SWIG_IsOK(res1)) {
45780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45781 }
45782 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45783 ecode2 = SWIG_AsVal_int(obj1, &val2);
45784 if (!SWIG_IsOK(ecode2)) {
45785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
45786 }
45787 arg2 = static_cast< int >(val2);
45788 {
45789 PyThreadState* __tstate = wxPyBeginAllowThreads();
45790 (arg1)->SetId(arg2);
45791 wxPyEndAllowThreads(__tstate);
45792 if (PyErr_Occurred()) SWIG_fail;
45793 }
45794 resultobj = SWIG_Py_Void();
45795 return resultobj;
45796 fail:
45797 return NULL;
45798 }
45799
45800
45801 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45802 PyObject *resultobj = 0;
45803 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45804 int result;
45805 void *argp1 = 0 ;
45806 int res1 = 0 ;
45807 PyObject *swig_obj[1] ;
45808
45809 if (!args) SWIG_fail;
45810 swig_obj[0] = args;
45811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45812 if (!SWIG_IsOK(res1)) {
45813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45814 }
45815 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45816 {
45817 PyThreadState* __tstate = wxPyBeginAllowThreads();
45818 result = (int)((wxMenuItem const *)arg1)->GetId();
45819 wxPyEndAllowThreads(__tstate);
45820 if (PyErr_Occurred()) SWIG_fail;
45821 }
45822 resultobj = SWIG_From_int(static_cast< int >(result));
45823 return resultobj;
45824 fail:
45825 return NULL;
45826 }
45827
45828
45829 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45830 PyObject *resultobj = 0;
45831 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45832 bool result;
45833 void *argp1 = 0 ;
45834 int res1 = 0 ;
45835 PyObject *swig_obj[1] ;
45836
45837 if (!args) SWIG_fail;
45838 swig_obj[0] = args;
45839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45840 if (!SWIG_IsOK(res1)) {
45841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45842 }
45843 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45844 {
45845 PyThreadState* __tstate = wxPyBeginAllowThreads();
45846 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
45847 wxPyEndAllowThreads(__tstate);
45848 if (PyErr_Occurred()) SWIG_fail;
45849 }
45850 {
45851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45852 }
45853 return resultobj;
45854 fail:
45855 return NULL;
45856 }
45857
45858
45859 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45860 PyObject *resultobj = 0;
45861 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45862 wxString *arg2 = 0 ;
45863 void *argp1 = 0 ;
45864 int res1 = 0 ;
45865 bool temp2 = false ;
45866 PyObject * obj0 = 0 ;
45867 PyObject * obj1 = 0 ;
45868 char * kwnames[] = {
45869 (char *) "self",(char *) "str", NULL
45870 };
45871
45872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
45873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45874 if (!SWIG_IsOK(res1)) {
45875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45876 }
45877 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45878 {
45879 arg2 = wxString_in_helper(obj1);
45880 if (arg2 == NULL) SWIG_fail;
45881 temp2 = true;
45882 }
45883 {
45884 PyThreadState* __tstate = wxPyBeginAllowThreads();
45885 (arg1)->SetText((wxString const &)*arg2);
45886 wxPyEndAllowThreads(__tstate);
45887 if (PyErr_Occurred()) SWIG_fail;
45888 }
45889 resultobj = SWIG_Py_Void();
45890 {
45891 if (temp2)
45892 delete arg2;
45893 }
45894 return resultobj;
45895 fail:
45896 {
45897 if (temp2)
45898 delete arg2;
45899 }
45900 return NULL;
45901 }
45902
45903
45904 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45905 PyObject *resultobj = 0;
45906 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45907 wxString result;
45908 void *argp1 = 0 ;
45909 int res1 = 0 ;
45910 PyObject *swig_obj[1] ;
45911
45912 if (!args) SWIG_fail;
45913 swig_obj[0] = args;
45914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45915 if (!SWIG_IsOK(res1)) {
45916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45917 }
45918 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45919 {
45920 PyThreadState* __tstate = wxPyBeginAllowThreads();
45921 result = ((wxMenuItem const *)arg1)->GetLabel();
45922 wxPyEndAllowThreads(__tstate);
45923 if (PyErr_Occurred()) SWIG_fail;
45924 }
45925 {
45926 #if wxUSE_UNICODE
45927 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45928 #else
45929 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45930 #endif
45931 }
45932 return resultobj;
45933 fail:
45934 return NULL;
45935 }
45936
45937
45938 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45939 PyObject *resultobj = 0;
45940 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45941 wxString *result = 0 ;
45942 void *argp1 = 0 ;
45943 int res1 = 0 ;
45944 PyObject *swig_obj[1] ;
45945
45946 if (!args) SWIG_fail;
45947 swig_obj[0] = args;
45948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45949 if (!SWIG_IsOK(res1)) {
45950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45951 }
45952 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45953 {
45954 PyThreadState* __tstate = wxPyBeginAllowThreads();
45955 {
45956 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
45957 result = (wxString *) &_result_ref;
45958 }
45959 wxPyEndAllowThreads(__tstate);
45960 if (PyErr_Occurred()) SWIG_fail;
45961 }
45962 {
45963 #if wxUSE_UNICODE
45964 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
45965 #else
45966 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
45967 #endif
45968 }
45969 return resultobj;
45970 fail:
45971 return NULL;
45972 }
45973
45974
45975 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45976 PyObject *resultobj = 0;
45977 wxString *arg1 = 0 ;
45978 wxString result;
45979 bool temp1 = false ;
45980 PyObject * obj0 = 0 ;
45981 char * kwnames[] = {
45982 (char *) "text", NULL
45983 };
45984
45985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
45986 {
45987 arg1 = wxString_in_helper(obj0);
45988 if (arg1 == NULL) SWIG_fail;
45989 temp1 = true;
45990 }
45991 {
45992 PyThreadState* __tstate = wxPyBeginAllowThreads();
45993 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
45994 wxPyEndAllowThreads(__tstate);
45995 if (PyErr_Occurred()) SWIG_fail;
45996 }
45997 {
45998 #if wxUSE_UNICODE
45999 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46000 #else
46001 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46002 #endif
46003 }
46004 {
46005 if (temp1)
46006 delete arg1;
46007 }
46008 return resultobj;
46009 fail:
46010 {
46011 if (temp1)
46012 delete arg1;
46013 }
46014 return NULL;
46015 }
46016
46017
46018 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46019 PyObject *resultobj = 0;
46020 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46021 wxItemKind result;
46022 void *argp1 = 0 ;
46023 int res1 = 0 ;
46024 PyObject *swig_obj[1] ;
46025
46026 if (!args) SWIG_fail;
46027 swig_obj[0] = args;
46028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46029 if (!SWIG_IsOK(res1)) {
46030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46031 }
46032 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46033 {
46034 PyThreadState* __tstate = wxPyBeginAllowThreads();
46035 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
46036 wxPyEndAllowThreads(__tstate);
46037 if (PyErr_Occurred()) SWIG_fail;
46038 }
46039 resultobj = SWIG_From_int(static_cast< int >(result));
46040 return resultobj;
46041 fail:
46042 return NULL;
46043 }
46044
46045
46046 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46047 PyObject *resultobj = 0;
46048 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46049 wxItemKind arg2 ;
46050 void *argp1 = 0 ;
46051 int res1 = 0 ;
46052 int val2 ;
46053 int ecode2 = 0 ;
46054 PyObject * obj0 = 0 ;
46055 PyObject * obj1 = 0 ;
46056 char * kwnames[] = {
46057 (char *) "self",(char *) "kind", NULL
46058 };
46059
46060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
46061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46062 if (!SWIG_IsOK(res1)) {
46063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46064 }
46065 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46066 ecode2 = SWIG_AsVal_int(obj1, &val2);
46067 if (!SWIG_IsOK(ecode2)) {
46068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
46069 }
46070 arg2 = static_cast< wxItemKind >(val2);
46071 {
46072 PyThreadState* __tstate = wxPyBeginAllowThreads();
46073 (arg1)->SetKind(arg2);
46074 wxPyEndAllowThreads(__tstate);
46075 if (PyErr_Occurred()) SWIG_fail;
46076 }
46077 resultobj = SWIG_Py_Void();
46078 return resultobj;
46079 fail:
46080 return NULL;
46081 }
46082
46083
46084 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46085 PyObject *resultobj = 0;
46086 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46087 bool arg2 ;
46088 void *argp1 = 0 ;
46089 int res1 = 0 ;
46090 bool val2 ;
46091 int ecode2 = 0 ;
46092 PyObject * obj0 = 0 ;
46093 PyObject * obj1 = 0 ;
46094 char * kwnames[] = {
46095 (char *) "self",(char *) "checkable", NULL
46096 };
46097
46098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
46099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46100 if (!SWIG_IsOK(res1)) {
46101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46102 }
46103 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46104 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46105 if (!SWIG_IsOK(ecode2)) {
46106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
46107 }
46108 arg2 = static_cast< bool >(val2);
46109 {
46110 PyThreadState* __tstate = wxPyBeginAllowThreads();
46111 (arg1)->SetCheckable(arg2);
46112 wxPyEndAllowThreads(__tstate);
46113 if (PyErr_Occurred()) SWIG_fail;
46114 }
46115 resultobj = SWIG_Py_Void();
46116 return resultobj;
46117 fail:
46118 return NULL;
46119 }
46120
46121
46122 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46123 PyObject *resultobj = 0;
46124 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46125 bool result;
46126 void *argp1 = 0 ;
46127 int res1 = 0 ;
46128 PyObject *swig_obj[1] ;
46129
46130 if (!args) SWIG_fail;
46131 swig_obj[0] = args;
46132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46133 if (!SWIG_IsOK(res1)) {
46134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46135 }
46136 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46137 {
46138 PyThreadState* __tstate = wxPyBeginAllowThreads();
46139 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
46140 wxPyEndAllowThreads(__tstate);
46141 if (PyErr_Occurred()) SWIG_fail;
46142 }
46143 {
46144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46145 }
46146 return resultobj;
46147 fail:
46148 return NULL;
46149 }
46150
46151
46152 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46153 PyObject *resultobj = 0;
46154 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46155 bool result;
46156 void *argp1 = 0 ;
46157 int res1 = 0 ;
46158 PyObject *swig_obj[1] ;
46159
46160 if (!args) SWIG_fail;
46161 swig_obj[0] = args;
46162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46163 if (!SWIG_IsOK(res1)) {
46164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46165 }
46166 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46167 {
46168 PyThreadState* __tstate = wxPyBeginAllowThreads();
46169 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
46170 wxPyEndAllowThreads(__tstate);
46171 if (PyErr_Occurred()) SWIG_fail;
46172 }
46173 {
46174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46175 }
46176 return resultobj;
46177 fail:
46178 return NULL;
46179 }
46180
46181
46182 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46183 PyObject *resultobj = 0;
46184 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46185 wxMenu *arg2 = (wxMenu *) 0 ;
46186 void *argp1 = 0 ;
46187 int res1 = 0 ;
46188 void *argp2 = 0 ;
46189 int res2 = 0 ;
46190 PyObject * obj0 = 0 ;
46191 PyObject * obj1 = 0 ;
46192 char * kwnames[] = {
46193 (char *) "self",(char *) "menu", NULL
46194 };
46195
46196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
46197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46198 if (!SWIG_IsOK(res1)) {
46199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46200 }
46201 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46202 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
46203 if (!SWIG_IsOK(res2)) {
46204 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46205 }
46206 arg2 = reinterpret_cast< wxMenu * >(argp2);
46207 {
46208 PyThreadState* __tstate = wxPyBeginAllowThreads();
46209 (arg1)->SetSubMenu(arg2);
46210 wxPyEndAllowThreads(__tstate);
46211 if (PyErr_Occurred()) SWIG_fail;
46212 }
46213 resultobj = SWIG_Py_Void();
46214 return resultobj;
46215 fail:
46216 return NULL;
46217 }
46218
46219
46220 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46221 PyObject *resultobj = 0;
46222 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46223 wxMenu *result = 0 ;
46224 void *argp1 = 0 ;
46225 int res1 = 0 ;
46226 PyObject *swig_obj[1] ;
46227
46228 if (!args) SWIG_fail;
46229 swig_obj[0] = args;
46230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46231 if (!SWIG_IsOK(res1)) {
46232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46233 }
46234 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46235 {
46236 PyThreadState* __tstate = wxPyBeginAllowThreads();
46237 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
46238 wxPyEndAllowThreads(__tstate);
46239 if (PyErr_Occurred()) SWIG_fail;
46240 }
46241 {
46242 resultobj = wxPyMake_wxObject(result, 0);
46243 }
46244 return resultobj;
46245 fail:
46246 return NULL;
46247 }
46248
46249
46250 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46251 PyObject *resultobj = 0;
46252 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46253 bool arg2 = (bool) true ;
46254 void *argp1 = 0 ;
46255 int res1 = 0 ;
46256 bool val2 ;
46257 int ecode2 = 0 ;
46258 PyObject * obj0 = 0 ;
46259 PyObject * obj1 = 0 ;
46260 char * kwnames[] = {
46261 (char *) "self",(char *) "enable", NULL
46262 };
46263
46264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
46265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46266 if (!SWIG_IsOK(res1)) {
46267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46268 }
46269 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46270 if (obj1) {
46271 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46272 if (!SWIG_IsOK(ecode2)) {
46273 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
46274 }
46275 arg2 = static_cast< bool >(val2);
46276 }
46277 {
46278 PyThreadState* __tstate = wxPyBeginAllowThreads();
46279 (arg1)->Enable(arg2);
46280 wxPyEndAllowThreads(__tstate);
46281 if (PyErr_Occurred()) SWIG_fail;
46282 }
46283 resultobj = SWIG_Py_Void();
46284 return resultobj;
46285 fail:
46286 return NULL;
46287 }
46288
46289
46290 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46291 PyObject *resultobj = 0;
46292 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46293 bool result;
46294 void *argp1 = 0 ;
46295 int res1 = 0 ;
46296 PyObject *swig_obj[1] ;
46297
46298 if (!args) SWIG_fail;
46299 swig_obj[0] = args;
46300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46301 if (!SWIG_IsOK(res1)) {
46302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46303 }
46304 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46305 {
46306 PyThreadState* __tstate = wxPyBeginAllowThreads();
46307 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
46308 wxPyEndAllowThreads(__tstate);
46309 if (PyErr_Occurred()) SWIG_fail;
46310 }
46311 {
46312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46313 }
46314 return resultobj;
46315 fail:
46316 return NULL;
46317 }
46318
46319
46320 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46321 PyObject *resultobj = 0;
46322 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46323 bool arg2 = (bool) true ;
46324 void *argp1 = 0 ;
46325 int res1 = 0 ;
46326 bool val2 ;
46327 int ecode2 = 0 ;
46328 PyObject * obj0 = 0 ;
46329 PyObject * obj1 = 0 ;
46330 char * kwnames[] = {
46331 (char *) "self",(char *) "check", NULL
46332 };
46333
46334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
46335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46336 if (!SWIG_IsOK(res1)) {
46337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46338 }
46339 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46340 if (obj1) {
46341 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46342 if (!SWIG_IsOK(ecode2)) {
46343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
46344 }
46345 arg2 = static_cast< bool >(val2);
46346 }
46347 {
46348 PyThreadState* __tstate = wxPyBeginAllowThreads();
46349 (arg1)->Check(arg2);
46350 wxPyEndAllowThreads(__tstate);
46351 if (PyErr_Occurred()) SWIG_fail;
46352 }
46353 resultobj = SWIG_Py_Void();
46354 return resultobj;
46355 fail:
46356 return NULL;
46357 }
46358
46359
46360 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46361 PyObject *resultobj = 0;
46362 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46363 bool result;
46364 void *argp1 = 0 ;
46365 int res1 = 0 ;
46366 PyObject *swig_obj[1] ;
46367
46368 if (!args) SWIG_fail;
46369 swig_obj[0] = args;
46370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46371 if (!SWIG_IsOK(res1)) {
46372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46373 }
46374 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46375 {
46376 PyThreadState* __tstate = wxPyBeginAllowThreads();
46377 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
46378 wxPyEndAllowThreads(__tstate);
46379 if (PyErr_Occurred()) SWIG_fail;
46380 }
46381 {
46382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46383 }
46384 return resultobj;
46385 fail:
46386 return NULL;
46387 }
46388
46389
46390 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46391 PyObject *resultobj = 0;
46392 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46393 void *argp1 = 0 ;
46394 int res1 = 0 ;
46395 PyObject *swig_obj[1] ;
46396
46397 if (!args) SWIG_fail;
46398 swig_obj[0] = args;
46399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46400 if (!SWIG_IsOK(res1)) {
46401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46402 }
46403 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46404 {
46405 PyThreadState* __tstate = wxPyBeginAllowThreads();
46406 (arg1)->Toggle();
46407 wxPyEndAllowThreads(__tstate);
46408 if (PyErr_Occurred()) SWIG_fail;
46409 }
46410 resultobj = SWIG_Py_Void();
46411 return resultobj;
46412 fail:
46413 return NULL;
46414 }
46415
46416
46417 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46418 PyObject *resultobj = 0;
46419 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46420 wxString *arg2 = 0 ;
46421 void *argp1 = 0 ;
46422 int res1 = 0 ;
46423 bool temp2 = false ;
46424 PyObject * obj0 = 0 ;
46425 PyObject * obj1 = 0 ;
46426 char * kwnames[] = {
46427 (char *) "self",(char *) "str", NULL
46428 };
46429
46430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
46431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46432 if (!SWIG_IsOK(res1)) {
46433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46434 }
46435 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46436 {
46437 arg2 = wxString_in_helper(obj1);
46438 if (arg2 == NULL) SWIG_fail;
46439 temp2 = true;
46440 }
46441 {
46442 PyThreadState* __tstate = wxPyBeginAllowThreads();
46443 (arg1)->SetHelp((wxString const &)*arg2);
46444 wxPyEndAllowThreads(__tstate);
46445 if (PyErr_Occurred()) SWIG_fail;
46446 }
46447 resultobj = SWIG_Py_Void();
46448 {
46449 if (temp2)
46450 delete arg2;
46451 }
46452 return resultobj;
46453 fail:
46454 {
46455 if (temp2)
46456 delete arg2;
46457 }
46458 return NULL;
46459 }
46460
46461
46462 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46463 PyObject *resultobj = 0;
46464 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46465 wxString *result = 0 ;
46466 void *argp1 = 0 ;
46467 int res1 = 0 ;
46468 PyObject *swig_obj[1] ;
46469
46470 if (!args) SWIG_fail;
46471 swig_obj[0] = args;
46472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46473 if (!SWIG_IsOK(res1)) {
46474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46475 }
46476 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46477 {
46478 PyThreadState* __tstate = wxPyBeginAllowThreads();
46479 {
46480 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
46481 result = (wxString *) &_result_ref;
46482 }
46483 wxPyEndAllowThreads(__tstate);
46484 if (PyErr_Occurred()) SWIG_fail;
46485 }
46486 {
46487 #if wxUSE_UNICODE
46488 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46489 #else
46490 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46491 #endif
46492 }
46493 return resultobj;
46494 fail:
46495 return NULL;
46496 }
46497
46498
46499 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46500 PyObject *resultobj = 0;
46501 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46502 wxAcceleratorEntry *result = 0 ;
46503 void *argp1 = 0 ;
46504 int res1 = 0 ;
46505 PyObject *swig_obj[1] ;
46506
46507 if (!args) SWIG_fail;
46508 swig_obj[0] = args;
46509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46510 if (!SWIG_IsOK(res1)) {
46511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46512 }
46513 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46514 {
46515 PyThreadState* __tstate = wxPyBeginAllowThreads();
46516 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
46517 wxPyEndAllowThreads(__tstate);
46518 if (PyErr_Occurred()) SWIG_fail;
46519 }
46520 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46521 return resultobj;
46522 fail:
46523 return NULL;
46524 }
46525
46526
46527 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46528 PyObject *resultobj = 0;
46529 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46530 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
46531 void *argp1 = 0 ;
46532 int res1 = 0 ;
46533 void *argp2 = 0 ;
46534 int res2 = 0 ;
46535 PyObject * obj0 = 0 ;
46536 PyObject * obj1 = 0 ;
46537 char * kwnames[] = {
46538 (char *) "self",(char *) "accel", NULL
46539 };
46540
46541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
46542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46543 if (!SWIG_IsOK(res1)) {
46544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46545 }
46546 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46547 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46548 if (!SWIG_IsOK(res2)) {
46549 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
46550 }
46551 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
46552 {
46553 PyThreadState* __tstate = wxPyBeginAllowThreads();
46554 (arg1)->SetAccel(arg2);
46555 wxPyEndAllowThreads(__tstate);
46556 if (PyErr_Occurred()) SWIG_fail;
46557 }
46558 resultobj = SWIG_Py_Void();
46559 return resultobj;
46560 fail:
46561 return NULL;
46562 }
46563
46564
46565 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46566 PyObject *resultobj = 0;
46567 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46568 wxBitmap *arg2 = 0 ;
46569 void *argp1 = 0 ;
46570 int res1 = 0 ;
46571 void *argp2 = 0 ;
46572 int res2 = 0 ;
46573 PyObject * obj0 = 0 ;
46574 PyObject * obj1 = 0 ;
46575 char * kwnames[] = {
46576 (char *) "self",(char *) "bitmap", NULL
46577 };
46578
46579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
46580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46581 if (!SWIG_IsOK(res1)) {
46582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46583 }
46584 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46585 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46586 if (!SWIG_IsOK(res2)) {
46587 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46588 }
46589 if (!argp2) {
46590 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46591 }
46592 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46593 {
46594 PyThreadState* __tstate = wxPyBeginAllowThreads();
46595 (arg1)->SetBitmap((wxBitmap const &)*arg2);
46596 wxPyEndAllowThreads(__tstate);
46597 if (PyErr_Occurred()) SWIG_fail;
46598 }
46599 resultobj = SWIG_Py_Void();
46600 return resultobj;
46601 fail:
46602 return NULL;
46603 }
46604
46605
46606 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46607 PyObject *resultobj = 0;
46608 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46609 wxBitmap *result = 0 ;
46610 void *argp1 = 0 ;
46611 int res1 = 0 ;
46612 PyObject *swig_obj[1] ;
46613
46614 if (!args) SWIG_fail;
46615 swig_obj[0] = args;
46616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46617 if (!SWIG_IsOK(res1)) {
46618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46619 }
46620 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46621 {
46622 PyThreadState* __tstate = wxPyBeginAllowThreads();
46623 {
46624 wxBitmap const &_result_ref = (arg1)->GetBitmap();
46625 result = (wxBitmap *) &_result_ref;
46626 }
46627 wxPyEndAllowThreads(__tstate);
46628 if (PyErr_Occurred()) SWIG_fail;
46629 }
46630 {
46631 wxBitmap* resultptr = new wxBitmap(*result);
46632 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
46633 }
46634 return resultobj;
46635 fail:
46636 return NULL;
46637 }
46638
46639
46640 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46641 PyObject *resultobj = 0;
46642 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46643 wxFont *arg2 = 0 ;
46644 void *argp1 = 0 ;
46645 int res1 = 0 ;
46646 void *argp2 = 0 ;
46647 int res2 = 0 ;
46648 PyObject * obj0 = 0 ;
46649 PyObject * obj1 = 0 ;
46650 char * kwnames[] = {
46651 (char *) "self",(char *) "font", NULL
46652 };
46653
46654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
46655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46656 if (!SWIG_IsOK(res1)) {
46657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46658 }
46659 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46660 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
46661 if (!SWIG_IsOK(res2)) {
46662 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46663 }
46664 if (!argp2) {
46665 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46666 }
46667 arg2 = reinterpret_cast< wxFont * >(argp2);
46668 {
46669 PyThreadState* __tstate = wxPyBeginAllowThreads();
46670 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
46671 wxPyEndAllowThreads(__tstate);
46672 if (PyErr_Occurred()) SWIG_fail;
46673 }
46674 resultobj = SWIG_Py_Void();
46675 return resultobj;
46676 fail:
46677 return NULL;
46678 }
46679
46680
46681 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46682 PyObject *resultobj = 0;
46683 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46684 wxFont result;
46685 void *argp1 = 0 ;
46686 int res1 = 0 ;
46687 PyObject *swig_obj[1] ;
46688
46689 if (!args) SWIG_fail;
46690 swig_obj[0] = args;
46691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46692 if (!SWIG_IsOK(res1)) {
46693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46694 }
46695 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46696 {
46697 PyThreadState* __tstate = wxPyBeginAllowThreads();
46698 result = wxMenuItem_GetFont(arg1);
46699 wxPyEndAllowThreads(__tstate);
46700 if (PyErr_Occurred()) SWIG_fail;
46701 }
46702 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
46703 return resultobj;
46704 fail:
46705 return NULL;
46706 }
46707
46708
46709 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46710 PyObject *resultobj = 0;
46711 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46712 wxColour *arg2 = 0 ;
46713 void *argp1 = 0 ;
46714 int res1 = 0 ;
46715 wxColour temp2 ;
46716 PyObject * obj0 = 0 ;
46717 PyObject * obj1 = 0 ;
46718 char * kwnames[] = {
46719 (char *) "self",(char *) "colText", NULL
46720 };
46721
46722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
46723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46724 if (!SWIG_IsOK(res1)) {
46725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46726 }
46727 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46728 {
46729 arg2 = &temp2;
46730 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46731 }
46732 {
46733 PyThreadState* __tstate = wxPyBeginAllowThreads();
46734 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
46735 wxPyEndAllowThreads(__tstate);
46736 if (PyErr_Occurred()) SWIG_fail;
46737 }
46738 resultobj = SWIG_Py_Void();
46739 return resultobj;
46740 fail:
46741 return NULL;
46742 }
46743
46744
46745 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46746 PyObject *resultobj = 0;
46747 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46748 wxColour result;
46749 void *argp1 = 0 ;
46750 int res1 = 0 ;
46751 PyObject *swig_obj[1] ;
46752
46753 if (!args) SWIG_fail;
46754 swig_obj[0] = args;
46755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46756 if (!SWIG_IsOK(res1)) {
46757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46758 }
46759 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46760 {
46761 PyThreadState* __tstate = wxPyBeginAllowThreads();
46762 result = wxMenuItem_GetTextColour(arg1);
46763 wxPyEndAllowThreads(__tstate);
46764 if (PyErr_Occurred()) SWIG_fail;
46765 }
46766 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
46767 return resultobj;
46768 fail:
46769 return NULL;
46770 }
46771
46772
46773 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46774 PyObject *resultobj = 0;
46775 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46776 wxColour *arg2 = 0 ;
46777 void *argp1 = 0 ;
46778 int res1 = 0 ;
46779 wxColour temp2 ;
46780 PyObject * obj0 = 0 ;
46781 PyObject * obj1 = 0 ;
46782 char * kwnames[] = {
46783 (char *) "self",(char *) "colBack", NULL
46784 };
46785
46786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
46787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46788 if (!SWIG_IsOK(res1)) {
46789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46790 }
46791 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46792 {
46793 arg2 = &temp2;
46794 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46795 }
46796 {
46797 PyThreadState* __tstate = wxPyBeginAllowThreads();
46798 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
46799 wxPyEndAllowThreads(__tstate);
46800 if (PyErr_Occurred()) SWIG_fail;
46801 }
46802 resultobj = SWIG_Py_Void();
46803 return resultobj;
46804 fail:
46805 return NULL;
46806 }
46807
46808
46809 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46810 PyObject *resultobj = 0;
46811 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46812 wxColour result;
46813 void *argp1 = 0 ;
46814 int res1 = 0 ;
46815 PyObject *swig_obj[1] ;
46816
46817 if (!args) SWIG_fail;
46818 swig_obj[0] = args;
46819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46820 if (!SWIG_IsOK(res1)) {
46821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46822 }
46823 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46824 {
46825 PyThreadState* __tstate = wxPyBeginAllowThreads();
46826 result = wxMenuItem_GetBackgroundColour(arg1);
46827 wxPyEndAllowThreads(__tstate);
46828 if (PyErr_Occurred()) SWIG_fail;
46829 }
46830 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
46831 return resultobj;
46832 fail:
46833 return NULL;
46834 }
46835
46836
46837 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46838 PyObject *resultobj = 0;
46839 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46840 wxBitmap *arg2 = 0 ;
46841 wxBitmap const &arg3_defvalue = wxNullBitmap ;
46842 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
46843 void *argp1 = 0 ;
46844 int res1 = 0 ;
46845 void *argp2 = 0 ;
46846 int res2 = 0 ;
46847 void *argp3 = 0 ;
46848 int res3 = 0 ;
46849 PyObject * obj0 = 0 ;
46850 PyObject * obj1 = 0 ;
46851 PyObject * obj2 = 0 ;
46852 char * kwnames[] = {
46853 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
46854 };
46855
46856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46858 if (!SWIG_IsOK(res1)) {
46859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46860 }
46861 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46862 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46863 if (!SWIG_IsOK(res2)) {
46864 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46865 }
46866 if (!argp2) {
46867 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46868 }
46869 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46870 if (obj2) {
46871 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
46872 if (!SWIG_IsOK(res3)) {
46873 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
46874 }
46875 if (!argp3) {
46876 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
46877 }
46878 arg3 = reinterpret_cast< wxBitmap * >(argp3);
46879 }
46880 {
46881 PyThreadState* __tstate = wxPyBeginAllowThreads();
46882 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
46883 wxPyEndAllowThreads(__tstate);
46884 if (PyErr_Occurred()) SWIG_fail;
46885 }
46886 resultobj = SWIG_Py_Void();
46887 return resultobj;
46888 fail:
46889 return NULL;
46890 }
46891
46892
46893 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46894 PyObject *resultobj = 0;
46895 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46896 wxBitmap *arg2 = 0 ;
46897 void *argp1 = 0 ;
46898 int res1 = 0 ;
46899 void *argp2 = 0 ;
46900 int res2 = 0 ;
46901 PyObject * obj0 = 0 ;
46902 PyObject * obj1 = 0 ;
46903 char * kwnames[] = {
46904 (char *) "self",(char *) "bmpDisabled", NULL
46905 };
46906
46907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
46908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46909 if (!SWIG_IsOK(res1)) {
46910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46911 }
46912 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46913 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46914 if (!SWIG_IsOK(res2)) {
46915 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46916 }
46917 if (!argp2) {
46918 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46919 }
46920 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46921 {
46922 PyThreadState* __tstate = wxPyBeginAllowThreads();
46923 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
46924 wxPyEndAllowThreads(__tstate);
46925 if (PyErr_Occurred()) SWIG_fail;
46926 }
46927 resultobj = SWIG_Py_Void();
46928 return resultobj;
46929 fail:
46930 return NULL;
46931 }
46932
46933
46934 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46935 PyObject *resultobj = 0;
46936 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46937 wxBitmap *result = 0 ;
46938 void *argp1 = 0 ;
46939 int res1 = 0 ;
46940 PyObject *swig_obj[1] ;
46941
46942 if (!args) SWIG_fail;
46943 swig_obj[0] = args;
46944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46945 if (!SWIG_IsOK(res1)) {
46946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46947 }
46948 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46949 {
46950 PyThreadState* __tstate = wxPyBeginAllowThreads();
46951 {
46952 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
46953 result = (wxBitmap *) &_result_ref;
46954 }
46955 wxPyEndAllowThreads(__tstate);
46956 if (PyErr_Occurred()) SWIG_fail;
46957 }
46958 {
46959 wxBitmap* resultptr = new wxBitmap(*result);
46960 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
46961 }
46962 return resultobj;
46963 fail:
46964 return NULL;
46965 }
46966
46967
46968 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46969 PyObject *resultobj = 0;
46970 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46971 int arg2 ;
46972 void *argp1 = 0 ;
46973 int res1 = 0 ;
46974 int val2 ;
46975 int ecode2 = 0 ;
46976 PyObject * obj0 = 0 ;
46977 PyObject * obj1 = 0 ;
46978 char * kwnames[] = {
46979 (char *) "self",(char *) "nWidth", NULL
46980 };
46981
46982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
46983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46984 if (!SWIG_IsOK(res1)) {
46985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46986 }
46987 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46988 ecode2 = SWIG_AsVal_int(obj1, &val2);
46989 if (!SWIG_IsOK(ecode2)) {
46990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
46991 }
46992 arg2 = static_cast< int >(val2);
46993 {
46994 PyThreadState* __tstate = wxPyBeginAllowThreads();
46995 wxMenuItem_SetMarginWidth(arg1,arg2);
46996 wxPyEndAllowThreads(__tstate);
46997 if (PyErr_Occurred()) SWIG_fail;
46998 }
46999 resultobj = SWIG_Py_Void();
47000 return resultobj;
47001 fail:
47002 return NULL;
47003 }
47004
47005
47006 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47007 PyObject *resultobj = 0;
47008 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47009 int result;
47010 void *argp1 = 0 ;
47011 int res1 = 0 ;
47012 PyObject *swig_obj[1] ;
47013
47014 if (!args) SWIG_fail;
47015 swig_obj[0] = args;
47016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47017 if (!SWIG_IsOK(res1)) {
47018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47019 }
47020 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47021 {
47022 PyThreadState* __tstate = wxPyBeginAllowThreads();
47023 result = (int)wxMenuItem_GetMarginWidth(arg1);
47024 wxPyEndAllowThreads(__tstate);
47025 if (PyErr_Occurred()) SWIG_fail;
47026 }
47027 resultobj = SWIG_From_int(static_cast< int >(result));
47028 return resultobj;
47029 fail:
47030 return NULL;
47031 }
47032
47033
47034 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47035 PyObject *resultobj = 0;
47036 int result;
47037
47038 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
47039 {
47040 PyThreadState* __tstate = wxPyBeginAllowThreads();
47041 result = (int)wxMenuItem_GetDefaultMarginWidth();
47042 wxPyEndAllowThreads(__tstate);
47043 if (PyErr_Occurred()) SWIG_fail;
47044 }
47045 resultobj = SWIG_From_int(static_cast< int >(result));
47046 return resultobj;
47047 fail:
47048 return NULL;
47049 }
47050
47051
47052 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47053 PyObject *resultobj = 0;
47054 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47055 bool result;
47056 void *argp1 = 0 ;
47057 int res1 = 0 ;
47058 PyObject *swig_obj[1] ;
47059
47060 if (!args) SWIG_fail;
47061 swig_obj[0] = args;
47062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47063 if (!SWIG_IsOK(res1)) {
47064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47065 }
47066 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47067 {
47068 PyThreadState* __tstate = wxPyBeginAllowThreads();
47069 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
47070 wxPyEndAllowThreads(__tstate);
47071 if (PyErr_Occurred()) SWIG_fail;
47072 }
47073 {
47074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47075 }
47076 return resultobj;
47077 fail:
47078 return NULL;
47079 }
47080
47081
47082 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47083 PyObject *resultobj = 0;
47084 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47085 bool arg2 = (bool) true ;
47086 void *argp1 = 0 ;
47087 int res1 = 0 ;
47088 bool val2 ;
47089 int ecode2 = 0 ;
47090 PyObject * obj0 = 0 ;
47091 PyObject * obj1 = 0 ;
47092 char * kwnames[] = {
47093 (char *) "self",(char *) "ownerDrawn", NULL
47094 };
47095
47096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
47097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47098 if (!SWIG_IsOK(res1)) {
47099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47100 }
47101 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47102 if (obj1) {
47103 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47104 if (!SWIG_IsOK(ecode2)) {
47105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
47106 }
47107 arg2 = static_cast< bool >(val2);
47108 }
47109 {
47110 PyThreadState* __tstate = wxPyBeginAllowThreads();
47111 wxMenuItem_SetOwnerDrawn(arg1,arg2);
47112 wxPyEndAllowThreads(__tstate);
47113 if (PyErr_Occurred()) SWIG_fail;
47114 }
47115 resultobj = SWIG_Py_Void();
47116 return resultobj;
47117 fail:
47118 return NULL;
47119 }
47120
47121
47122 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47123 PyObject *resultobj = 0;
47124 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47125 void *argp1 = 0 ;
47126 int res1 = 0 ;
47127 PyObject *swig_obj[1] ;
47128
47129 if (!args) SWIG_fail;
47130 swig_obj[0] = args;
47131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47132 if (!SWIG_IsOK(res1)) {
47133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47134 }
47135 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47136 {
47137 PyThreadState* __tstate = wxPyBeginAllowThreads();
47138 wxMenuItem_ResetOwnerDrawn(arg1);
47139 wxPyEndAllowThreads(__tstate);
47140 if (PyErr_Occurred()) SWIG_fail;
47141 }
47142 resultobj = SWIG_Py_Void();
47143 return resultobj;
47144 fail:
47145 return NULL;
47146 }
47147
47148
47149 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47150 PyObject *obj;
47151 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47152 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
47153 return SWIG_Py_Void();
47154 }
47155
47156 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47157 return SWIG_Python_InitShadowInstance(args);
47158 }
47159
47160 SWIGINTERN int ControlNameStr_set(PyObject *) {
47161 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
47162 return 1;
47163 }
47164
47165
47166 SWIGINTERN PyObject *ControlNameStr_get(void) {
47167 PyObject *pyobj = 0;
47168
47169 {
47170 #if wxUSE_UNICODE
47171 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47172 #else
47173 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47174 #endif
47175 }
47176 return pyobj;
47177 }
47178
47179
47180 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47181 PyObject *resultobj = 0;
47182 wxWindow *arg1 = (wxWindow *) 0 ;
47183 int arg2 = (int) -1 ;
47184 wxPoint const &arg3_defvalue = wxDefaultPosition ;
47185 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
47186 wxSize const &arg4_defvalue = wxDefaultSize ;
47187 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
47188 long arg5 = (long) 0 ;
47189 wxValidator const &arg6_defvalue = wxDefaultValidator ;
47190 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
47191 wxString const &arg7_defvalue = wxPyControlNameStr ;
47192 wxString *arg7 = (wxString *) &arg7_defvalue ;
47193 wxControl *result = 0 ;
47194 void *argp1 = 0 ;
47195 int res1 = 0 ;
47196 int val2 ;
47197 int ecode2 = 0 ;
47198 wxPoint temp3 ;
47199 wxSize temp4 ;
47200 long val5 ;
47201 int ecode5 = 0 ;
47202 void *argp6 = 0 ;
47203 int res6 = 0 ;
47204 bool temp7 = false ;
47205 PyObject * obj0 = 0 ;
47206 PyObject * obj1 = 0 ;
47207 PyObject * obj2 = 0 ;
47208 PyObject * obj3 = 0 ;
47209 PyObject * obj4 = 0 ;
47210 PyObject * obj5 = 0 ;
47211 PyObject * obj6 = 0 ;
47212 char * kwnames[] = {
47213 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47214 };
47215
47216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
47218 if (!SWIG_IsOK(res1)) {
47219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
47220 }
47221 arg1 = reinterpret_cast< wxWindow * >(argp1);
47222 if (obj1) {
47223 ecode2 = SWIG_AsVal_int(obj1, &val2);
47224 if (!SWIG_IsOK(ecode2)) {
47225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
47226 }
47227 arg2 = static_cast< int >(val2);
47228 }
47229 if (obj2) {
47230 {
47231 arg3 = &temp3;
47232 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
47233 }
47234 }
47235 if (obj3) {
47236 {
47237 arg4 = &temp4;
47238 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
47239 }
47240 }
47241 if (obj4) {
47242 ecode5 = SWIG_AsVal_long(obj4, &val5);
47243 if (!SWIG_IsOK(ecode5)) {
47244 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
47245 }
47246 arg5 = static_cast< long >(val5);
47247 }
47248 if (obj5) {
47249 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
47250 if (!SWIG_IsOK(res6)) {
47251 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47252 }
47253 if (!argp6) {
47254 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47255 }
47256 arg6 = reinterpret_cast< wxValidator * >(argp6);
47257 }
47258 if (obj6) {
47259 {
47260 arg7 = wxString_in_helper(obj6);
47261 if (arg7 == NULL) SWIG_fail;
47262 temp7 = true;
47263 }
47264 }
47265 {
47266 if (!wxPyCheckForApp()) SWIG_fail;
47267 PyThreadState* __tstate = wxPyBeginAllowThreads();
47268 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
47269 wxPyEndAllowThreads(__tstate);
47270 if (PyErr_Occurred()) SWIG_fail;
47271 }
47272 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
47273 {
47274 if (temp7)
47275 delete arg7;
47276 }
47277 return resultobj;
47278 fail:
47279 {
47280 if (temp7)
47281 delete arg7;
47282 }
47283 return NULL;
47284 }
47285
47286
47287 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47288 PyObject *resultobj = 0;
47289 wxControl *result = 0 ;
47290
47291 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
47292 {
47293 if (!wxPyCheckForApp()) SWIG_fail;
47294 PyThreadState* __tstate = wxPyBeginAllowThreads();
47295 result = (wxControl *)new wxControl();
47296 wxPyEndAllowThreads(__tstate);
47297 if (PyErr_Occurred()) SWIG_fail;
47298 }
47299 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
47300 return resultobj;
47301 fail:
47302 return NULL;
47303 }
47304
47305
47306 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47307 PyObject *resultobj = 0;
47308 wxControl *arg1 = (wxControl *) 0 ;
47309 wxWindow *arg2 = (wxWindow *) 0 ;
47310 int arg3 = (int) -1 ;
47311 wxPoint const &arg4_defvalue = wxDefaultPosition ;
47312 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
47313 wxSize const &arg5_defvalue = wxDefaultSize ;
47314 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
47315 long arg6 = (long) 0 ;
47316 wxValidator const &arg7_defvalue = wxDefaultValidator ;
47317 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
47318 wxString const &arg8_defvalue = wxPyControlNameStr ;
47319 wxString *arg8 = (wxString *) &arg8_defvalue ;
47320 bool result;
47321 void *argp1 = 0 ;
47322 int res1 = 0 ;
47323 void *argp2 = 0 ;
47324 int res2 = 0 ;
47325 int val3 ;
47326 int ecode3 = 0 ;
47327 wxPoint temp4 ;
47328 wxSize temp5 ;
47329 long val6 ;
47330 int ecode6 = 0 ;
47331 void *argp7 = 0 ;
47332 int res7 = 0 ;
47333 bool temp8 = false ;
47334 PyObject * obj0 = 0 ;
47335 PyObject * obj1 = 0 ;
47336 PyObject * obj2 = 0 ;
47337 PyObject * obj3 = 0 ;
47338 PyObject * obj4 = 0 ;
47339 PyObject * obj5 = 0 ;
47340 PyObject * obj6 = 0 ;
47341 PyObject * obj7 = 0 ;
47342 char * kwnames[] = {
47343 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47344 };
47345
47346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
47347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47348 if (!SWIG_IsOK(res1)) {
47349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
47350 }
47351 arg1 = reinterpret_cast< wxControl * >(argp1);
47352 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47353 if (!SWIG_IsOK(res2)) {
47354 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
47355 }
47356 arg2 = reinterpret_cast< wxWindow * >(argp2);
47357 if (obj2) {
47358 ecode3 = SWIG_AsVal_int(obj2, &val3);
47359 if (!SWIG_IsOK(ecode3)) {
47360 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
47361 }
47362 arg3 = static_cast< int >(val3);
47363 }
47364 if (obj3) {
47365 {
47366 arg4 = &temp4;
47367 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
47368 }
47369 }
47370 if (obj4) {
47371 {
47372 arg5 = &temp5;
47373 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
47374 }
47375 }
47376 if (obj5) {
47377 ecode6 = SWIG_AsVal_long(obj5, &val6);
47378 if (!SWIG_IsOK(ecode6)) {
47379 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
47380 }
47381 arg6 = static_cast< long >(val6);
47382 }
47383 if (obj6) {
47384 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
47385 if (!SWIG_IsOK(res7)) {
47386 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47387 }
47388 if (!argp7) {
47389 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47390 }
47391 arg7 = reinterpret_cast< wxValidator * >(argp7);
47392 }
47393 if (obj7) {
47394 {
47395 arg8 = wxString_in_helper(obj7);
47396 if (arg8 == NULL) SWIG_fail;
47397 temp8 = true;
47398 }
47399 }
47400 {
47401 PyThreadState* __tstate = wxPyBeginAllowThreads();
47402 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
47403 wxPyEndAllowThreads(__tstate);
47404 if (PyErr_Occurred()) SWIG_fail;
47405 }
47406 {
47407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47408 }
47409 {
47410 if (temp8)
47411 delete arg8;
47412 }
47413 return resultobj;
47414 fail:
47415 {
47416 if (temp8)
47417 delete arg8;
47418 }
47419 return NULL;
47420 }
47421
47422
47423 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47424 PyObject *resultobj = 0;
47425 wxControl *arg1 = (wxControl *) 0 ;
47426 int result;
47427 void *argp1 = 0 ;
47428 int res1 = 0 ;
47429 PyObject *swig_obj[1] ;
47430
47431 if (!args) SWIG_fail;
47432 swig_obj[0] = args;
47433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47434 if (!SWIG_IsOK(res1)) {
47435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
47436 }
47437 arg1 = reinterpret_cast< wxControl * >(argp1);
47438 {
47439 PyThreadState* __tstate = wxPyBeginAllowThreads();
47440 result = (int)((wxControl const *)arg1)->GetAlignment();
47441 wxPyEndAllowThreads(__tstate);
47442 if (PyErr_Occurred()) SWIG_fail;
47443 }
47444 resultobj = SWIG_From_int(static_cast< int >(result));
47445 return resultobj;
47446 fail:
47447 return NULL;
47448 }
47449
47450
47451 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47452 PyObject *resultobj = 0;
47453 wxControl *arg1 = (wxControl *) 0 ;
47454 wxString result;
47455 void *argp1 = 0 ;
47456 int res1 = 0 ;
47457 PyObject *swig_obj[1] ;
47458
47459 if (!args) SWIG_fail;
47460 swig_obj[0] = args;
47461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47462 if (!SWIG_IsOK(res1)) {
47463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
47464 }
47465 arg1 = reinterpret_cast< wxControl * >(argp1);
47466 {
47467 PyThreadState* __tstate = wxPyBeginAllowThreads();
47468 result = ((wxControl const *)arg1)->GetLabelText();
47469 wxPyEndAllowThreads(__tstate);
47470 if (PyErr_Occurred()) SWIG_fail;
47471 }
47472 {
47473 #if wxUSE_UNICODE
47474 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
47475 #else
47476 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
47477 #endif
47478 }
47479 return resultobj;
47480 fail:
47481 return NULL;
47482 }
47483
47484
47485 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47486 PyObject *resultobj = 0;
47487 wxControl *arg1 = (wxControl *) 0 ;
47488 wxCommandEvent *arg2 = 0 ;
47489 void *argp1 = 0 ;
47490 int res1 = 0 ;
47491 void *argp2 = 0 ;
47492 int res2 = 0 ;
47493 PyObject * obj0 = 0 ;
47494 PyObject * obj1 = 0 ;
47495 char * kwnames[] = {
47496 (char *) "self",(char *) "event", NULL
47497 };
47498
47499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
47500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47501 if (!SWIG_IsOK(res1)) {
47502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
47503 }
47504 arg1 = reinterpret_cast< wxControl * >(argp1);
47505 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
47506 if (!SWIG_IsOK(res2)) {
47507 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47508 }
47509 if (!argp2) {
47510 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47511 }
47512 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
47513 {
47514 PyThreadState* __tstate = wxPyBeginAllowThreads();
47515 (arg1)->Command(*arg2);
47516 wxPyEndAllowThreads(__tstate);
47517 if (PyErr_Occurred()) SWIG_fail;
47518 }
47519 resultobj = SWIG_Py_Void();
47520 return resultobj;
47521 fail:
47522 return NULL;
47523 }
47524
47525
47526 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47527 PyObject *resultobj = 0;
47528 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
47529 SwigValueWrapper<wxVisualAttributes > result;
47530 int val1 ;
47531 int ecode1 = 0 ;
47532 PyObject * obj0 = 0 ;
47533 char * kwnames[] = {
47534 (char *) "variant", NULL
47535 };
47536
47537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
47538 if (obj0) {
47539 ecode1 = SWIG_AsVal_int(obj0, &val1);
47540 if (!SWIG_IsOK(ecode1)) {
47541 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
47542 }
47543 arg1 = static_cast< wxWindowVariant >(val1);
47544 }
47545 {
47546 if (!wxPyCheckForApp()) SWIG_fail;
47547 PyThreadState* __tstate = wxPyBeginAllowThreads();
47548 result = wxControl::GetClassDefaultAttributes(arg1);
47549 wxPyEndAllowThreads(__tstate);
47550 if (PyErr_Occurred()) SWIG_fail;
47551 }
47552 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
47553 return resultobj;
47554 fail:
47555 return NULL;
47556 }
47557
47558
47559 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47560 PyObject *obj;
47561 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47562 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
47563 return SWIG_Py_Void();
47564 }
47565
47566 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47567 return SWIG_Python_InitShadowInstance(args);
47568 }
47569
47570 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47571 PyObject *resultobj = 0;
47572 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47573 wxString *arg2 = 0 ;
47574 PyObject *arg3 = (PyObject *) NULL ;
47575 int result;
47576 void *argp1 = 0 ;
47577 int res1 = 0 ;
47578 bool temp2 = false ;
47579 PyObject * obj0 = 0 ;
47580 PyObject * obj1 = 0 ;
47581 PyObject * obj2 = 0 ;
47582 char * kwnames[] = {
47583 (char *) "self",(char *) "item",(char *) "clientData", NULL
47584 };
47585
47586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47588 if (!SWIG_IsOK(res1)) {
47589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47590 }
47591 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47592 {
47593 arg2 = wxString_in_helper(obj1);
47594 if (arg2 == NULL) SWIG_fail;
47595 temp2 = true;
47596 }
47597 if (obj2) {
47598 arg3 = obj2;
47599 }
47600 {
47601 PyThreadState* __tstate = wxPyBeginAllowThreads();
47602 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
47603 wxPyEndAllowThreads(__tstate);
47604 if (PyErr_Occurred()) SWIG_fail;
47605 }
47606 resultobj = SWIG_From_int(static_cast< int >(result));
47607 {
47608 if (temp2)
47609 delete arg2;
47610 }
47611 return resultobj;
47612 fail:
47613 {
47614 if (temp2)
47615 delete arg2;
47616 }
47617 return NULL;
47618 }
47619
47620
47621 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47622 PyObject *resultobj = 0;
47623 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47624 wxArrayString *arg2 = 0 ;
47625 void *argp1 = 0 ;
47626 int res1 = 0 ;
47627 bool temp2 = false ;
47628 PyObject * obj0 = 0 ;
47629 PyObject * obj1 = 0 ;
47630 char * kwnames[] = {
47631 (char *) "self",(char *) "strings", NULL
47632 };
47633
47634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
47635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47636 if (!SWIG_IsOK(res1)) {
47637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47638 }
47639 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47640 {
47641 if (! PySequence_Check(obj1)) {
47642 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
47643 SWIG_fail;
47644 }
47645 arg2 = new wxArrayString;
47646 temp2 = true;
47647 int i, len=PySequence_Length(obj1);
47648 for (i=0; i<len; i++) {
47649 PyObject* item = PySequence_GetItem(obj1, i);
47650 wxString* s = wxString_in_helper(item);
47651 if (PyErr_Occurred()) SWIG_fail;
47652 arg2->Add(*s);
47653 delete s;
47654 Py_DECREF(item);
47655 }
47656 }
47657 {
47658 PyThreadState* __tstate = wxPyBeginAllowThreads();
47659 (arg1)->Append((wxArrayString const &)*arg2);
47660 wxPyEndAllowThreads(__tstate);
47661 if (PyErr_Occurred()) SWIG_fail;
47662 }
47663 resultobj = SWIG_Py_Void();
47664 {
47665 if (temp2) delete arg2;
47666 }
47667 return resultobj;
47668 fail:
47669 {
47670 if (temp2) delete arg2;
47671 }
47672 return NULL;
47673 }
47674
47675
47676 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47677 PyObject *resultobj = 0;
47678 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47679 wxString *arg2 = 0 ;
47680 unsigned int arg3 ;
47681 PyObject *arg4 = (PyObject *) NULL ;
47682 int result;
47683 void *argp1 = 0 ;
47684 int res1 = 0 ;
47685 bool temp2 = false ;
47686 unsigned int val3 ;
47687 int ecode3 = 0 ;
47688 PyObject * obj0 = 0 ;
47689 PyObject * obj1 = 0 ;
47690 PyObject * obj2 = 0 ;
47691 PyObject * obj3 = 0 ;
47692 char * kwnames[] = {
47693 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
47694 };
47695
47696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47698 if (!SWIG_IsOK(res1)) {
47699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47700 }
47701 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47702 {
47703 arg2 = wxString_in_helper(obj1);
47704 if (arg2 == NULL) SWIG_fail;
47705 temp2 = true;
47706 }
47707 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
47708 if (!SWIG_IsOK(ecode3)) {
47709 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
47710 }
47711 arg3 = static_cast< unsigned int >(val3);
47712 if (obj3) {
47713 arg4 = obj3;
47714 }
47715 {
47716 PyThreadState* __tstate = wxPyBeginAllowThreads();
47717 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
47718 wxPyEndAllowThreads(__tstate);
47719 if (PyErr_Occurred()) SWIG_fail;
47720 }
47721 resultobj = SWIG_From_int(static_cast< int >(result));
47722 {
47723 if (temp2)
47724 delete arg2;
47725 }
47726 return resultobj;
47727 fail:
47728 {
47729 if (temp2)
47730 delete arg2;
47731 }
47732 return NULL;
47733 }
47734
47735
47736 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47737 PyObject *resultobj = 0;
47738 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47739 void *argp1 = 0 ;
47740 int res1 = 0 ;
47741 PyObject *swig_obj[1] ;
47742
47743 if (!args) SWIG_fail;
47744 swig_obj[0] = args;
47745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47746 if (!SWIG_IsOK(res1)) {
47747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47748 }
47749 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47750 {
47751 PyThreadState* __tstate = wxPyBeginAllowThreads();
47752 (arg1)->Clear();
47753 wxPyEndAllowThreads(__tstate);
47754 if (PyErr_Occurred()) SWIG_fail;
47755 }
47756 resultobj = SWIG_Py_Void();
47757 return resultobj;
47758 fail:
47759 return NULL;
47760 }
47761
47762
47763 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47764 PyObject *resultobj = 0;
47765 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47766 unsigned int arg2 ;
47767 void *argp1 = 0 ;
47768 int res1 = 0 ;
47769 unsigned int val2 ;
47770 int ecode2 = 0 ;
47771 PyObject * obj0 = 0 ;
47772 PyObject * obj1 = 0 ;
47773 char * kwnames[] = {
47774 (char *) "self",(char *) "n", NULL
47775 };
47776
47777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
47778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47779 if (!SWIG_IsOK(res1)) {
47780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47781 }
47782 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47783 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47784 if (!SWIG_IsOK(ecode2)) {
47785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
47786 }
47787 arg2 = static_cast< unsigned int >(val2);
47788 {
47789 PyThreadState* __tstate = wxPyBeginAllowThreads();
47790 (arg1)->Delete(arg2);
47791 wxPyEndAllowThreads(__tstate);
47792 if (PyErr_Occurred()) SWIG_fail;
47793 }
47794 resultobj = SWIG_Py_Void();
47795 return resultobj;
47796 fail:
47797 return NULL;
47798 }
47799
47800
47801 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47802 PyObject *resultobj = 0;
47803 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47804 unsigned int arg2 ;
47805 PyObject *result = 0 ;
47806 void *argp1 = 0 ;
47807 int res1 = 0 ;
47808 unsigned int val2 ;
47809 int ecode2 = 0 ;
47810 PyObject * obj0 = 0 ;
47811 PyObject * obj1 = 0 ;
47812 char * kwnames[] = {
47813 (char *) "self",(char *) "n", NULL
47814 };
47815
47816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
47817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47818 if (!SWIG_IsOK(res1)) {
47819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47820 }
47821 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47822 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47823 if (!SWIG_IsOK(ecode2)) {
47824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
47825 }
47826 arg2 = static_cast< unsigned int >(val2);
47827 {
47828 PyThreadState* __tstate = wxPyBeginAllowThreads();
47829 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
47830 wxPyEndAllowThreads(__tstate);
47831 if (PyErr_Occurred()) SWIG_fail;
47832 }
47833 resultobj = result;
47834 return resultobj;
47835 fail:
47836 return NULL;
47837 }
47838
47839
47840 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47841 PyObject *resultobj = 0;
47842 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47843 unsigned int arg2 ;
47844 PyObject *arg3 = (PyObject *) 0 ;
47845 void *argp1 = 0 ;
47846 int res1 = 0 ;
47847 unsigned int val2 ;
47848 int ecode2 = 0 ;
47849 PyObject * obj0 = 0 ;
47850 PyObject * obj1 = 0 ;
47851 PyObject * obj2 = 0 ;
47852 char * kwnames[] = {
47853 (char *) "self",(char *) "n",(char *) "clientData", NULL
47854 };
47855
47856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47858 if (!SWIG_IsOK(res1)) {
47859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47860 }
47861 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47862 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47863 if (!SWIG_IsOK(ecode2)) {
47864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
47865 }
47866 arg2 = static_cast< unsigned int >(val2);
47867 arg3 = obj2;
47868 {
47869 PyThreadState* __tstate = wxPyBeginAllowThreads();
47870 wxItemContainer_SetClientData(arg1,arg2,arg3);
47871 wxPyEndAllowThreads(__tstate);
47872 if (PyErr_Occurred()) SWIG_fail;
47873 }
47874 resultobj = SWIG_Py_Void();
47875 return resultobj;
47876 fail:
47877 return NULL;
47878 }
47879
47880
47881 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47882 PyObject *resultobj = 0;
47883 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47884 unsigned int result;
47885 void *argp1 = 0 ;
47886 int res1 = 0 ;
47887 PyObject *swig_obj[1] ;
47888
47889 if (!args) SWIG_fail;
47890 swig_obj[0] = args;
47891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47892 if (!SWIG_IsOK(res1)) {
47893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
47894 }
47895 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47896 {
47897 PyThreadState* __tstate = wxPyBeginAllowThreads();
47898 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
47899 wxPyEndAllowThreads(__tstate);
47900 if (PyErr_Occurred()) SWIG_fail;
47901 }
47902 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
47903 return resultobj;
47904 fail:
47905 return NULL;
47906 }
47907
47908
47909 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47910 PyObject *resultobj = 0;
47911 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47912 bool result;
47913 void *argp1 = 0 ;
47914 int res1 = 0 ;
47915 PyObject *swig_obj[1] ;
47916
47917 if (!args) SWIG_fail;
47918 swig_obj[0] = args;
47919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47920 if (!SWIG_IsOK(res1)) {
47921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
47922 }
47923 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47924 {
47925 PyThreadState* __tstate = wxPyBeginAllowThreads();
47926 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
47927 wxPyEndAllowThreads(__tstate);
47928 if (PyErr_Occurred()) SWIG_fail;
47929 }
47930 {
47931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47932 }
47933 return resultobj;
47934 fail:
47935 return NULL;
47936 }
47937
47938
47939 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47940 PyObject *resultobj = 0;
47941 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47942 unsigned int arg2 ;
47943 wxString result;
47944 void *argp1 = 0 ;
47945 int res1 = 0 ;
47946 unsigned int val2 ;
47947 int ecode2 = 0 ;
47948 PyObject * obj0 = 0 ;
47949 PyObject * obj1 = 0 ;
47950 char * kwnames[] = {
47951 (char *) "self",(char *) "n", NULL
47952 };
47953
47954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
47955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47956 if (!SWIG_IsOK(res1)) {
47957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
47958 }
47959 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47960 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47961 if (!SWIG_IsOK(ecode2)) {
47962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
47963 }
47964 arg2 = static_cast< unsigned int >(val2);
47965 {
47966 PyThreadState* __tstate = wxPyBeginAllowThreads();
47967 result = ((wxItemContainer const *)arg1)->GetString(arg2);
47968 wxPyEndAllowThreads(__tstate);
47969 if (PyErr_Occurred()) SWIG_fail;
47970 }
47971 {
47972 #if wxUSE_UNICODE
47973 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
47974 #else
47975 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
47976 #endif
47977 }
47978 return resultobj;
47979 fail:
47980 return NULL;
47981 }
47982
47983
47984 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47985 PyObject *resultobj = 0;
47986 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47987 wxArrayString result;
47988 void *argp1 = 0 ;
47989 int res1 = 0 ;
47990 PyObject *swig_obj[1] ;
47991
47992 if (!args) SWIG_fail;
47993 swig_obj[0] = args;
47994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47995 if (!SWIG_IsOK(res1)) {
47996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
47997 }
47998 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47999 {
48000 PyThreadState* __tstate = wxPyBeginAllowThreads();
48001 result = ((wxItemContainer const *)arg1)->GetStrings();
48002 wxPyEndAllowThreads(__tstate);
48003 if (PyErr_Occurred()) SWIG_fail;
48004 }
48005 {
48006 resultobj = wxArrayString2PyList_helper(result);
48007 }
48008 return resultobj;
48009 fail:
48010 return NULL;
48011 }
48012
48013
48014 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48015 PyObject *resultobj = 0;
48016 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48017 unsigned int arg2 ;
48018 wxString *arg3 = 0 ;
48019 void *argp1 = 0 ;
48020 int res1 = 0 ;
48021 unsigned int val2 ;
48022 int ecode2 = 0 ;
48023 bool temp3 = false ;
48024 PyObject * obj0 = 0 ;
48025 PyObject * obj1 = 0 ;
48026 PyObject * obj2 = 0 ;
48027 char * kwnames[] = {
48028 (char *) "self",(char *) "n",(char *) "s", NULL
48029 };
48030
48031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48033 if (!SWIG_IsOK(res1)) {
48034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48035 }
48036 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48037 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
48038 if (!SWIG_IsOK(ecode2)) {
48039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
48040 }
48041 arg2 = static_cast< unsigned int >(val2);
48042 {
48043 arg3 = wxString_in_helper(obj2);
48044 if (arg3 == NULL) SWIG_fail;
48045 temp3 = true;
48046 }
48047 {
48048 PyThreadState* __tstate = wxPyBeginAllowThreads();
48049 (arg1)->SetString(arg2,(wxString const &)*arg3);
48050 wxPyEndAllowThreads(__tstate);
48051 if (PyErr_Occurred()) SWIG_fail;
48052 }
48053 resultobj = SWIG_Py_Void();
48054 {
48055 if (temp3)
48056 delete arg3;
48057 }
48058 return resultobj;
48059 fail:
48060 {
48061 if (temp3)
48062 delete arg3;
48063 }
48064 return NULL;
48065 }
48066
48067
48068 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48069 PyObject *resultobj = 0;
48070 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48071 wxString *arg2 = 0 ;
48072 int result;
48073 void *argp1 = 0 ;
48074 int res1 = 0 ;
48075 bool temp2 = false ;
48076 PyObject * obj0 = 0 ;
48077 PyObject * obj1 = 0 ;
48078 char * kwnames[] = {
48079 (char *) "self",(char *) "s", NULL
48080 };
48081
48082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
48083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48084 if (!SWIG_IsOK(res1)) {
48085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48086 }
48087 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48088 {
48089 arg2 = wxString_in_helper(obj1);
48090 if (arg2 == NULL) SWIG_fail;
48091 temp2 = true;
48092 }
48093 {
48094 PyThreadState* __tstate = wxPyBeginAllowThreads();
48095 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
48096 wxPyEndAllowThreads(__tstate);
48097 if (PyErr_Occurred()) SWIG_fail;
48098 }
48099 resultobj = SWIG_From_int(static_cast< int >(result));
48100 {
48101 if (temp2)
48102 delete arg2;
48103 }
48104 return resultobj;
48105 fail:
48106 {
48107 if (temp2)
48108 delete arg2;
48109 }
48110 return NULL;
48111 }
48112
48113
48114 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48115 PyObject *resultobj = 0;
48116 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48117 int arg2 ;
48118 void *argp1 = 0 ;
48119 int res1 = 0 ;
48120 int val2 ;
48121 int ecode2 = 0 ;
48122 PyObject * obj0 = 0 ;
48123 PyObject * obj1 = 0 ;
48124 char * kwnames[] = {
48125 (char *) "self",(char *) "n", NULL
48126 };
48127
48128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48130 if (!SWIG_IsOK(res1)) {
48131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48132 }
48133 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48134 ecode2 = SWIG_AsVal_int(obj1, &val2);
48135 if (!SWIG_IsOK(ecode2)) {
48136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
48137 }
48138 arg2 = static_cast< int >(val2);
48139 {
48140 PyThreadState* __tstate = wxPyBeginAllowThreads();
48141 (arg1)->SetSelection(arg2);
48142 wxPyEndAllowThreads(__tstate);
48143 if (PyErr_Occurred()) SWIG_fail;
48144 }
48145 resultobj = SWIG_Py_Void();
48146 return resultobj;
48147 fail:
48148 return NULL;
48149 }
48150
48151
48152 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48153 PyObject *resultobj = 0;
48154 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48155 int result;
48156 void *argp1 = 0 ;
48157 int res1 = 0 ;
48158 PyObject *swig_obj[1] ;
48159
48160 if (!args) SWIG_fail;
48161 swig_obj[0] = args;
48162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48163 if (!SWIG_IsOK(res1)) {
48164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48165 }
48166 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48167 {
48168 PyThreadState* __tstate = wxPyBeginAllowThreads();
48169 result = (int)((wxItemContainer const *)arg1)->GetSelection();
48170 wxPyEndAllowThreads(__tstate);
48171 if (PyErr_Occurred()) SWIG_fail;
48172 }
48173 resultobj = SWIG_From_int(static_cast< int >(result));
48174 return resultobj;
48175 fail:
48176 return NULL;
48177 }
48178
48179
48180 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48181 PyObject *resultobj = 0;
48182 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48183 wxString *arg2 = 0 ;
48184 bool result;
48185 void *argp1 = 0 ;
48186 int res1 = 0 ;
48187 bool temp2 = false ;
48188 PyObject * obj0 = 0 ;
48189 PyObject * obj1 = 0 ;
48190 char * kwnames[] = {
48191 (char *) "self",(char *) "s", NULL
48192 };
48193
48194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48196 if (!SWIG_IsOK(res1)) {
48197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48198 }
48199 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48200 {
48201 arg2 = wxString_in_helper(obj1);
48202 if (arg2 == NULL) SWIG_fail;
48203 temp2 = true;
48204 }
48205 {
48206 PyThreadState* __tstate = wxPyBeginAllowThreads();
48207 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
48208 wxPyEndAllowThreads(__tstate);
48209 if (PyErr_Occurred()) SWIG_fail;
48210 }
48211 {
48212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48213 }
48214 {
48215 if (temp2)
48216 delete arg2;
48217 }
48218 return resultobj;
48219 fail:
48220 {
48221 if (temp2)
48222 delete arg2;
48223 }
48224 return NULL;
48225 }
48226
48227
48228 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48229 PyObject *resultobj = 0;
48230 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48231 wxString result;
48232 void *argp1 = 0 ;
48233 int res1 = 0 ;
48234 PyObject *swig_obj[1] ;
48235
48236 if (!args) SWIG_fail;
48237 swig_obj[0] = args;
48238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48239 if (!SWIG_IsOK(res1)) {
48240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48241 }
48242 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48243 {
48244 PyThreadState* __tstate = wxPyBeginAllowThreads();
48245 result = ((wxItemContainer const *)arg1)->GetStringSelection();
48246 wxPyEndAllowThreads(__tstate);
48247 if (PyErr_Occurred()) SWIG_fail;
48248 }
48249 {
48250 #if wxUSE_UNICODE
48251 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48252 #else
48253 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48254 #endif
48255 }
48256 return resultobj;
48257 fail:
48258 return NULL;
48259 }
48260
48261
48262 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48263 PyObject *resultobj = 0;
48264 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48265 int arg2 ;
48266 void *argp1 = 0 ;
48267 int res1 = 0 ;
48268 int val2 ;
48269 int ecode2 = 0 ;
48270 PyObject * obj0 = 0 ;
48271 PyObject * obj1 = 0 ;
48272 char * kwnames[] = {
48273 (char *) "self",(char *) "n", NULL
48274 };
48275
48276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
48277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48278 if (!SWIG_IsOK(res1)) {
48279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48280 }
48281 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48282 ecode2 = SWIG_AsVal_int(obj1, &val2);
48283 if (!SWIG_IsOK(ecode2)) {
48284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
48285 }
48286 arg2 = static_cast< int >(val2);
48287 {
48288 PyThreadState* __tstate = wxPyBeginAllowThreads();
48289 (arg1)->Select(arg2);
48290 wxPyEndAllowThreads(__tstate);
48291 if (PyErr_Occurred()) SWIG_fail;
48292 }
48293 resultobj = SWIG_Py_Void();
48294 return resultobj;
48295 fail:
48296 return NULL;
48297 }
48298
48299
48300 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48301 PyObject *obj;
48302 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48303 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
48304 return SWIG_Py_Void();
48305 }
48306
48307 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48308 PyObject *obj;
48309 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48310 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
48311 return SWIG_Py_Void();
48312 }
48313
48314 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48315 PyObject *resultobj = 0;
48316 wxSizerItem *result = 0 ;
48317
48318 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
48319 {
48320 PyThreadState* __tstate = wxPyBeginAllowThreads();
48321 result = (wxSizerItem *)new wxSizerItem();
48322 wxPyEndAllowThreads(__tstate);
48323 if (PyErr_Occurred()) SWIG_fail;
48324 }
48325 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
48326 return resultobj;
48327 fail:
48328 return NULL;
48329 }
48330
48331
48332 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48333 PyObject *resultobj = 0;
48334 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48335 void *argp1 = 0 ;
48336 int res1 = 0 ;
48337 PyObject *swig_obj[1] ;
48338
48339 if (!args) SWIG_fail;
48340 swig_obj[0] = args;
48341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48342 if (!SWIG_IsOK(res1)) {
48343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48344 }
48345 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48346 {
48347 PyThreadState* __tstate = wxPyBeginAllowThreads();
48348 delete arg1;
48349
48350 wxPyEndAllowThreads(__tstate);
48351 if (PyErr_Occurred()) SWIG_fail;
48352 }
48353 resultobj = SWIG_Py_Void();
48354 return resultobj;
48355 fail:
48356 return NULL;
48357 }
48358
48359
48360 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48361 PyObject *resultobj = 0;
48362 wxWindow *arg1 = (wxWindow *) 0 ;
48363 int arg2 ;
48364 int arg3 ;
48365 int arg4 ;
48366 PyObject *arg5 = (PyObject *) NULL ;
48367 wxSizerItem *result = 0 ;
48368 void *argp1 = 0 ;
48369 int res1 = 0 ;
48370 int val2 ;
48371 int ecode2 = 0 ;
48372 int val3 ;
48373 int ecode3 = 0 ;
48374 int val4 ;
48375 int ecode4 = 0 ;
48376 PyObject * obj0 = 0 ;
48377 PyObject * obj1 = 0 ;
48378 PyObject * obj2 = 0 ;
48379 PyObject * obj3 = 0 ;
48380 PyObject * obj4 = 0 ;
48381 char * kwnames[] = {
48382 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48383 };
48384
48385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
48387 if (!SWIG_IsOK(res1)) {
48388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
48389 }
48390 arg1 = reinterpret_cast< wxWindow * >(argp1);
48391 ecode2 = SWIG_AsVal_int(obj1, &val2);
48392 if (!SWIG_IsOK(ecode2)) {
48393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
48394 }
48395 arg2 = static_cast< int >(val2);
48396 ecode3 = SWIG_AsVal_int(obj2, &val3);
48397 if (!SWIG_IsOK(ecode3)) {
48398 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
48399 }
48400 arg3 = static_cast< int >(val3);
48401 ecode4 = SWIG_AsVal_int(obj3, &val4);
48402 if (!SWIG_IsOK(ecode4)) {
48403 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
48404 }
48405 arg4 = static_cast< int >(val4);
48406 if (obj4) {
48407 arg5 = obj4;
48408 }
48409 {
48410 PyThreadState* __tstate = wxPyBeginAllowThreads();
48411 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48412 wxPyEndAllowThreads(__tstate);
48413 if (PyErr_Occurred()) SWIG_fail;
48414 }
48415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48416 return resultobj;
48417 fail:
48418 return NULL;
48419 }
48420
48421
48422 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48423 PyObject *resultobj = 0;
48424 int arg1 ;
48425 int arg2 ;
48426 int arg3 ;
48427 int arg4 ;
48428 int arg5 ;
48429 PyObject *arg6 = (PyObject *) NULL ;
48430 wxSizerItem *result = 0 ;
48431 int val1 ;
48432 int ecode1 = 0 ;
48433 int val2 ;
48434 int ecode2 = 0 ;
48435 int val3 ;
48436 int ecode3 = 0 ;
48437 int val4 ;
48438 int ecode4 = 0 ;
48439 int val5 ;
48440 int ecode5 = 0 ;
48441 PyObject * obj0 = 0 ;
48442 PyObject * obj1 = 0 ;
48443 PyObject * obj2 = 0 ;
48444 PyObject * obj3 = 0 ;
48445 PyObject * obj4 = 0 ;
48446 PyObject * obj5 = 0 ;
48447 char * kwnames[] = {
48448 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48449 };
48450
48451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
48452 ecode1 = SWIG_AsVal_int(obj0, &val1);
48453 if (!SWIG_IsOK(ecode1)) {
48454 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
48455 }
48456 arg1 = static_cast< int >(val1);
48457 ecode2 = SWIG_AsVal_int(obj1, &val2);
48458 if (!SWIG_IsOK(ecode2)) {
48459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
48460 }
48461 arg2 = static_cast< int >(val2);
48462 ecode3 = SWIG_AsVal_int(obj2, &val3);
48463 if (!SWIG_IsOK(ecode3)) {
48464 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
48465 }
48466 arg3 = static_cast< int >(val3);
48467 ecode4 = SWIG_AsVal_int(obj3, &val4);
48468 if (!SWIG_IsOK(ecode4)) {
48469 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
48470 }
48471 arg4 = static_cast< int >(val4);
48472 ecode5 = SWIG_AsVal_int(obj4, &val5);
48473 if (!SWIG_IsOK(ecode5)) {
48474 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
48475 }
48476 arg5 = static_cast< int >(val5);
48477 if (obj5) {
48478 arg6 = obj5;
48479 }
48480 {
48481 PyThreadState* __tstate = wxPyBeginAllowThreads();
48482 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
48483 wxPyEndAllowThreads(__tstate);
48484 if (PyErr_Occurred()) SWIG_fail;
48485 }
48486 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48487 return resultobj;
48488 fail:
48489 return NULL;
48490 }
48491
48492
48493 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48494 PyObject *resultobj = 0;
48495 wxSizer *arg1 = (wxSizer *) 0 ;
48496 int arg2 ;
48497 int arg3 ;
48498 int arg4 ;
48499 PyObject *arg5 = (PyObject *) NULL ;
48500 wxSizerItem *result = 0 ;
48501 int res1 = 0 ;
48502 int val2 ;
48503 int ecode2 = 0 ;
48504 int val3 ;
48505 int ecode3 = 0 ;
48506 int val4 ;
48507 int ecode4 = 0 ;
48508 PyObject * obj0 = 0 ;
48509 PyObject * obj1 = 0 ;
48510 PyObject * obj2 = 0 ;
48511 PyObject * obj3 = 0 ;
48512 PyObject * obj4 = 0 ;
48513 char * kwnames[] = {
48514 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48515 };
48516
48517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48518 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
48519 if (!SWIG_IsOK(res1)) {
48520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
48521 }
48522 ecode2 = SWIG_AsVal_int(obj1, &val2);
48523 if (!SWIG_IsOK(ecode2)) {
48524 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
48525 }
48526 arg2 = static_cast< int >(val2);
48527 ecode3 = SWIG_AsVal_int(obj2, &val3);
48528 if (!SWIG_IsOK(ecode3)) {
48529 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
48530 }
48531 arg3 = static_cast< int >(val3);
48532 ecode4 = SWIG_AsVal_int(obj3, &val4);
48533 if (!SWIG_IsOK(ecode4)) {
48534 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
48535 }
48536 arg4 = static_cast< int >(val4);
48537 if (obj4) {
48538 arg5 = obj4;
48539 }
48540 {
48541 PyThreadState* __tstate = wxPyBeginAllowThreads();
48542 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48543 wxPyEndAllowThreads(__tstate);
48544 if (PyErr_Occurred()) SWIG_fail;
48545 }
48546 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48547 return resultobj;
48548 fail:
48549 return NULL;
48550 }
48551
48552
48553 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48554 PyObject *resultobj = 0;
48555 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48556 void *argp1 = 0 ;
48557 int res1 = 0 ;
48558 PyObject *swig_obj[1] ;
48559
48560 if (!args) SWIG_fail;
48561 swig_obj[0] = args;
48562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48563 if (!SWIG_IsOK(res1)) {
48564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48565 }
48566 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48567 {
48568 PyThreadState* __tstate = wxPyBeginAllowThreads();
48569 (arg1)->DeleteWindows();
48570 wxPyEndAllowThreads(__tstate);
48571 if (PyErr_Occurred()) SWIG_fail;
48572 }
48573 resultobj = SWIG_Py_Void();
48574 return resultobj;
48575 fail:
48576 return NULL;
48577 }
48578
48579
48580 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48581 PyObject *resultobj = 0;
48582 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48583 void *argp1 = 0 ;
48584 int res1 = 0 ;
48585 PyObject *swig_obj[1] ;
48586
48587 if (!args) SWIG_fail;
48588 swig_obj[0] = args;
48589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48590 if (!SWIG_IsOK(res1)) {
48591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48592 }
48593 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48594 {
48595 PyThreadState* __tstate = wxPyBeginAllowThreads();
48596 (arg1)->DetachSizer();
48597 wxPyEndAllowThreads(__tstate);
48598 if (PyErr_Occurred()) SWIG_fail;
48599 }
48600 resultobj = SWIG_Py_Void();
48601 return resultobj;
48602 fail:
48603 return NULL;
48604 }
48605
48606
48607 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48608 PyObject *resultobj = 0;
48609 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48610 wxSize result;
48611 void *argp1 = 0 ;
48612 int res1 = 0 ;
48613 PyObject *swig_obj[1] ;
48614
48615 if (!args) SWIG_fail;
48616 swig_obj[0] = args;
48617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48618 if (!SWIG_IsOK(res1)) {
48619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48620 }
48621 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48622 {
48623 PyThreadState* __tstate = wxPyBeginAllowThreads();
48624 result = (arg1)->GetSize();
48625 wxPyEndAllowThreads(__tstate);
48626 if (PyErr_Occurred()) SWIG_fail;
48627 }
48628 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48629 return resultobj;
48630 fail:
48631 return NULL;
48632 }
48633
48634
48635 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48636 PyObject *resultobj = 0;
48637 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48638 wxSize result;
48639 void *argp1 = 0 ;
48640 int res1 = 0 ;
48641 PyObject *swig_obj[1] ;
48642
48643 if (!args) SWIG_fail;
48644 swig_obj[0] = args;
48645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48646 if (!SWIG_IsOK(res1)) {
48647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48648 }
48649 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48650 {
48651 PyThreadState* __tstate = wxPyBeginAllowThreads();
48652 result = (arg1)->CalcMin();
48653 wxPyEndAllowThreads(__tstate);
48654 if (PyErr_Occurred()) SWIG_fail;
48655 }
48656 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48657 return resultobj;
48658 fail:
48659 return NULL;
48660 }
48661
48662
48663 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48664 PyObject *resultobj = 0;
48665 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48666 wxPoint *arg2 = 0 ;
48667 wxSize *arg3 = 0 ;
48668 void *argp1 = 0 ;
48669 int res1 = 0 ;
48670 wxPoint temp2 ;
48671 wxSize temp3 ;
48672 PyObject * obj0 = 0 ;
48673 PyObject * obj1 = 0 ;
48674 PyObject * obj2 = 0 ;
48675 char * kwnames[] = {
48676 (char *) "self",(char *) "pos",(char *) "size", NULL
48677 };
48678
48679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48681 if (!SWIG_IsOK(res1)) {
48682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48683 }
48684 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48685 {
48686 arg2 = &temp2;
48687 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
48688 }
48689 {
48690 arg3 = &temp3;
48691 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
48692 }
48693 {
48694 PyThreadState* __tstate = wxPyBeginAllowThreads();
48695 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
48696 wxPyEndAllowThreads(__tstate);
48697 if (PyErr_Occurred()) SWIG_fail;
48698 }
48699 resultobj = SWIG_Py_Void();
48700 return resultobj;
48701 fail:
48702 return NULL;
48703 }
48704
48705
48706 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48707 PyObject *resultobj = 0;
48708 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48709 wxSize result;
48710 void *argp1 = 0 ;
48711 int res1 = 0 ;
48712 PyObject *swig_obj[1] ;
48713
48714 if (!args) SWIG_fail;
48715 swig_obj[0] = args;
48716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48717 if (!SWIG_IsOK(res1)) {
48718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48719 }
48720 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48721 {
48722 PyThreadState* __tstate = wxPyBeginAllowThreads();
48723 result = (arg1)->GetMinSize();
48724 wxPyEndAllowThreads(__tstate);
48725 if (PyErr_Occurred()) SWIG_fail;
48726 }
48727 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48728 return resultobj;
48729 fail:
48730 return NULL;
48731 }
48732
48733
48734 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48735 PyObject *resultobj = 0;
48736 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48737 wxSize result;
48738 void *argp1 = 0 ;
48739 int res1 = 0 ;
48740 PyObject *swig_obj[1] ;
48741
48742 if (!args) SWIG_fail;
48743 swig_obj[0] = args;
48744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48745 if (!SWIG_IsOK(res1)) {
48746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
48747 }
48748 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48749 {
48750 PyThreadState* __tstate = wxPyBeginAllowThreads();
48751 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
48752 wxPyEndAllowThreads(__tstate);
48753 if (PyErr_Occurred()) SWIG_fail;
48754 }
48755 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48756 return resultobj;
48757 fail:
48758 return NULL;
48759 }
48760
48761
48762 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48763 PyObject *resultobj = 0;
48764 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48765 int arg2 ;
48766 int arg3 ;
48767 void *argp1 = 0 ;
48768 int res1 = 0 ;
48769 int val2 ;
48770 int ecode2 = 0 ;
48771 int val3 ;
48772 int ecode3 = 0 ;
48773 PyObject * obj0 = 0 ;
48774 PyObject * obj1 = 0 ;
48775 PyObject * obj2 = 0 ;
48776 char * kwnames[] = {
48777 (char *) "self",(char *) "x",(char *) "y", NULL
48778 };
48779
48780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48782 if (!SWIG_IsOK(res1)) {
48783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48784 }
48785 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48786 ecode2 = SWIG_AsVal_int(obj1, &val2);
48787 if (!SWIG_IsOK(ecode2)) {
48788 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
48789 }
48790 arg2 = static_cast< int >(val2);
48791 ecode3 = SWIG_AsVal_int(obj2, &val3);
48792 if (!SWIG_IsOK(ecode3)) {
48793 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
48794 }
48795 arg3 = static_cast< int >(val3);
48796 {
48797 PyThreadState* __tstate = wxPyBeginAllowThreads();
48798 (arg1)->SetInitSize(arg2,arg3);
48799 wxPyEndAllowThreads(__tstate);
48800 if (PyErr_Occurred()) SWIG_fail;
48801 }
48802 resultobj = SWIG_Py_Void();
48803 return resultobj;
48804 fail:
48805 return NULL;
48806 }
48807
48808
48809 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48810 PyObject *resultobj = 0;
48811 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48812 int arg2 ;
48813 int arg3 ;
48814 void *argp1 = 0 ;
48815 int res1 = 0 ;
48816 int val2 ;
48817 int ecode2 = 0 ;
48818 int val3 ;
48819 int ecode3 = 0 ;
48820 PyObject * obj0 = 0 ;
48821 PyObject * obj1 = 0 ;
48822 PyObject * obj2 = 0 ;
48823 char * kwnames[] = {
48824 (char *) "self",(char *) "width",(char *) "height", NULL
48825 };
48826
48827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48829 if (!SWIG_IsOK(res1)) {
48830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48831 }
48832 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48833 ecode2 = SWIG_AsVal_int(obj1, &val2);
48834 if (!SWIG_IsOK(ecode2)) {
48835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
48836 }
48837 arg2 = static_cast< int >(val2);
48838 ecode3 = SWIG_AsVal_int(obj2, &val3);
48839 if (!SWIG_IsOK(ecode3)) {
48840 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
48841 }
48842 arg3 = static_cast< int >(val3);
48843 {
48844 PyThreadState* __tstate = wxPyBeginAllowThreads();
48845 (arg1)->SetRatio(arg2,arg3);
48846 wxPyEndAllowThreads(__tstate);
48847 if (PyErr_Occurred()) SWIG_fail;
48848 }
48849 resultobj = SWIG_Py_Void();
48850 return resultobj;
48851 fail:
48852 return NULL;
48853 }
48854
48855
48856 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48857 PyObject *resultobj = 0;
48858 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48859 wxSize *arg2 = 0 ;
48860 void *argp1 = 0 ;
48861 int res1 = 0 ;
48862 wxSize temp2 ;
48863 PyObject * obj0 = 0 ;
48864 PyObject * obj1 = 0 ;
48865 char * kwnames[] = {
48866 (char *) "self",(char *) "size", NULL
48867 };
48868
48869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
48870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48871 if (!SWIG_IsOK(res1)) {
48872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48873 }
48874 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48875 {
48876 arg2 = &temp2;
48877 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
48878 }
48879 {
48880 PyThreadState* __tstate = wxPyBeginAllowThreads();
48881 (arg1)->SetRatio((wxSize const &)*arg2);
48882 wxPyEndAllowThreads(__tstate);
48883 if (PyErr_Occurred()) SWIG_fail;
48884 }
48885 resultobj = SWIG_Py_Void();
48886 return resultobj;
48887 fail:
48888 return NULL;
48889 }
48890
48891
48892 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48893 PyObject *resultobj = 0;
48894 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48895 float arg2 ;
48896 void *argp1 = 0 ;
48897 int res1 = 0 ;
48898 float val2 ;
48899 int ecode2 = 0 ;
48900 PyObject * obj0 = 0 ;
48901 PyObject * obj1 = 0 ;
48902 char * kwnames[] = {
48903 (char *) "self",(char *) "ratio", NULL
48904 };
48905
48906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
48907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48908 if (!SWIG_IsOK(res1)) {
48909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48910 }
48911 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48912 ecode2 = SWIG_AsVal_float(obj1, &val2);
48913 if (!SWIG_IsOK(ecode2)) {
48914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
48915 }
48916 arg2 = static_cast< float >(val2);
48917 {
48918 PyThreadState* __tstate = wxPyBeginAllowThreads();
48919 (arg1)->SetRatio(arg2);
48920 wxPyEndAllowThreads(__tstate);
48921 if (PyErr_Occurred()) SWIG_fail;
48922 }
48923 resultobj = SWIG_Py_Void();
48924 return resultobj;
48925 fail:
48926 return NULL;
48927 }
48928
48929
48930 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48931 PyObject *resultobj = 0;
48932 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48933 float result;
48934 void *argp1 = 0 ;
48935 int res1 = 0 ;
48936 PyObject *swig_obj[1] ;
48937
48938 if (!args) SWIG_fail;
48939 swig_obj[0] = args;
48940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48941 if (!SWIG_IsOK(res1)) {
48942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48943 }
48944 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48945 {
48946 PyThreadState* __tstate = wxPyBeginAllowThreads();
48947 result = (float)(arg1)->GetRatio();
48948 wxPyEndAllowThreads(__tstate);
48949 if (PyErr_Occurred()) SWIG_fail;
48950 }
48951 resultobj = SWIG_From_float(static_cast< float >(result));
48952 return resultobj;
48953 fail:
48954 return NULL;
48955 }
48956
48957
48958 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48959 PyObject *resultobj = 0;
48960 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48961 wxRect result;
48962 void *argp1 = 0 ;
48963 int res1 = 0 ;
48964 PyObject *swig_obj[1] ;
48965
48966 if (!args) SWIG_fail;
48967 swig_obj[0] = args;
48968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48969 if (!SWIG_IsOK(res1)) {
48970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48971 }
48972 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48973 {
48974 PyThreadState* __tstate = wxPyBeginAllowThreads();
48975 result = (arg1)->GetRect();
48976 wxPyEndAllowThreads(__tstate);
48977 if (PyErr_Occurred()) SWIG_fail;
48978 }
48979 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
48980 return resultobj;
48981 fail:
48982 return NULL;
48983 }
48984
48985
48986 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48987 PyObject *resultobj = 0;
48988 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48989 bool result;
48990 void *argp1 = 0 ;
48991 int res1 = 0 ;
48992 PyObject *swig_obj[1] ;
48993
48994 if (!args) SWIG_fail;
48995 swig_obj[0] = args;
48996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48997 if (!SWIG_IsOK(res1)) {
48998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48999 }
49000 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49001 {
49002 PyThreadState* __tstate = wxPyBeginAllowThreads();
49003 result = (bool)(arg1)->IsWindow();
49004 wxPyEndAllowThreads(__tstate);
49005 if (PyErr_Occurred()) SWIG_fail;
49006 }
49007 {
49008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49009 }
49010 return resultobj;
49011 fail:
49012 return NULL;
49013 }
49014
49015
49016 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49017 PyObject *resultobj = 0;
49018 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49019 bool result;
49020 void *argp1 = 0 ;
49021 int res1 = 0 ;
49022 PyObject *swig_obj[1] ;
49023
49024 if (!args) SWIG_fail;
49025 swig_obj[0] = args;
49026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49027 if (!SWIG_IsOK(res1)) {
49028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49029 }
49030 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49031 {
49032 PyThreadState* __tstate = wxPyBeginAllowThreads();
49033 result = (bool)(arg1)->IsSizer();
49034 wxPyEndAllowThreads(__tstate);
49035 if (PyErr_Occurred()) SWIG_fail;
49036 }
49037 {
49038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49039 }
49040 return resultobj;
49041 fail:
49042 return NULL;
49043 }
49044
49045
49046 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49047 PyObject *resultobj = 0;
49048 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49049 bool result;
49050 void *argp1 = 0 ;
49051 int res1 = 0 ;
49052 PyObject *swig_obj[1] ;
49053
49054 if (!args) SWIG_fail;
49055 swig_obj[0] = args;
49056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49057 if (!SWIG_IsOK(res1)) {
49058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49059 }
49060 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49061 {
49062 PyThreadState* __tstate = wxPyBeginAllowThreads();
49063 result = (bool)(arg1)->IsSpacer();
49064 wxPyEndAllowThreads(__tstate);
49065 if (PyErr_Occurred()) SWIG_fail;
49066 }
49067 {
49068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49069 }
49070 return resultobj;
49071 fail:
49072 return NULL;
49073 }
49074
49075
49076 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49077 PyObject *resultobj = 0;
49078 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49079 int arg2 ;
49080 void *argp1 = 0 ;
49081 int res1 = 0 ;
49082 int val2 ;
49083 int ecode2 = 0 ;
49084 PyObject * obj0 = 0 ;
49085 PyObject * obj1 = 0 ;
49086 char * kwnames[] = {
49087 (char *) "self",(char *) "proportion", NULL
49088 };
49089
49090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
49091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49092 if (!SWIG_IsOK(res1)) {
49093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49094 }
49095 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49096 ecode2 = SWIG_AsVal_int(obj1, &val2);
49097 if (!SWIG_IsOK(ecode2)) {
49098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
49099 }
49100 arg2 = static_cast< int >(val2);
49101 {
49102 PyThreadState* __tstate = wxPyBeginAllowThreads();
49103 (arg1)->SetProportion(arg2);
49104 wxPyEndAllowThreads(__tstate);
49105 if (PyErr_Occurred()) SWIG_fail;
49106 }
49107 resultobj = SWIG_Py_Void();
49108 return resultobj;
49109 fail:
49110 return NULL;
49111 }
49112
49113
49114 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49115 PyObject *resultobj = 0;
49116 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49117 int result;
49118 void *argp1 = 0 ;
49119 int res1 = 0 ;
49120 PyObject *swig_obj[1] ;
49121
49122 if (!args) SWIG_fail;
49123 swig_obj[0] = args;
49124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49125 if (!SWIG_IsOK(res1)) {
49126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49127 }
49128 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49129 {
49130 PyThreadState* __tstate = wxPyBeginAllowThreads();
49131 result = (int)(arg1)->GetProportion();
49132 wxPyEndAllowThreads(__tstate);
49133 if (PyErr_Occurred()) SWIG_fail;
49134 }
49135 resultobj = SWIG_From_int(static_cast< int >(result));
49136 return resultobj;
49137 fail:
49138 return NULL;
49139 }
49140
49141
49142 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49143 PyObject *resultobj = 0;
49144 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49145 int arg2 ;
49146 void *argp1 = 0 ;
49147 int res1 = 0 ;
49148 int val2 ;
49149 int ecode2 = 0 ;
49150 PyObject * obj0 = 0 ;
49151 PyObject * obj1 = 0 ;
49152 char * kwnames[] = {
49153 (char *) "self",(char *) "flag", NULL
49154 };
49155
49156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
49157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49158 if (!SWIG_IsOK(res1)) {
49159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49160 }
49161 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49162 ecode2 = SWIG_AsVal_int(obj1, &val2);
49163 if (!SWIG_IsOK(ecode2)) {
49164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
49165 }
49166 arg2 = static_cast< int >(val2);
49167 {
49168 PyThreadState* __tstate = wxPyBeginAllowThreads();
49169 (arg1)->SetFlag(arg2);
49170 wxPyEndAllowThreads(__tstate);
49171 if (PyErr_Occurred()) SWIG_fail;
49172 }
49173 resultobj = SWIG_Py_Void();
49174 return resultobj;
49175 fail:
49176 return NULL;
49177 }
49178
49179
49180 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49181 PyObject *resultobj = 0;
49182 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49183 int result;
49184 void *argp1 = 0 ;
49185 int res1 = 0 ;
49186 PyObject *swig_obj[1] ;
49187
49188 if (!args) SWIG_fail;
49189 swig_obj[0] = args;
49190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49191 if (!SWIG_IsOK(res1)) {
49192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49193 }
49194 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49195 {
49196 PyThreadState* __tstate = wxPyBeginAllowThreads();
49197 result = (int)(arg1)->GetFlag();
49198 wxPyEndAllowThreads(__tstate);
49199 if (PyErr_Occurred()) SWIG_fail;
49200 }
49201 resultobj = SWIG_From_int(static_cast< int >(result));
49202 return resultobj;
49203 fail:
49204 return NULL;
49205 }
49206
49207
49208 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49209 PyObject *resultobj = 0;
49210 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49211 int arg2 ;
49212 void *argp1 = 0 ;
49213 int res1 = 0 ;
49214 int val2 ;
49215 int ecode2 = 0 ;
49216 PyObject * obj0 = 0 ;
49217 PyObject * obj1 = 0 ;
49218 char * kwnames[] = {
49219 (char *) "self",(char *) "border", NULL
49220 };
49221
49222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49224 if (!SWIG_IsOK(res1)) {
49225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49226 }
49227 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49228 ecode2 = SWIG_AsVal_int(obj1, &val2);
49229 if (!SWIG_IsOK(ecode2)) {
49230 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
49231 }
49232 arg2 = static_cast< int >(val2);
49233 {
49234 PyThreadState* __tstate = wxPyBeginAllowThreads();
49235 (arg1)->SetBorder(arg2);
49236 wxPyEndAllowThreads(__tstate);
49237 if (PyErr_Occurred()) SWIG_fail;
49238 }
49239 resultobj = SWIG_Py_Void();
49240 return resultobj;
49241 fail:
49242 return NULL;
49243 }
49244
49245
49246 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49247 PyObject *resultobj = 0;
49248 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49249 int result;
49250 void *argp1 = 0 ;
49251 int res1 = 0 ;
49252 PyObject *swig_obj[1] ;
49253
49254 if (!args) SWIG_fail;
49255 swig_obj[0] = args;
49256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49257 if (!SWIG_IsOK(res1)) {
49258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49259 }
49260 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49261 {
49262 PyThreadState* __tstate = wxPyBeginAllowThreads();
49263 result = (int)(arg1)->GetBorder();
49264 wxPyEndAllowThreads(__tstate);
49265 if (PyErr_Occurred()) SWIG_fail;
49266 }
49267 resultobj = SWIG_From_int(static_cast< int >(result));
49268 return resultobj;
49269 fail:
49270 return NULL;
49271 }
49272
49273
49274 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49275 PyObject *resultobj = 0;
49276 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49277 wxWindow *result = 0 ;
49278 void *argp1 = 0 ;
49279 int res1 = 0 ;
49280 PyObject *swig_obj[1] ;
49281
49282 if (!args) SWIG_fail;
49283 swig_obj[0] = args;
49284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49285 if (!SWIG_IsOK(res1)) {
49286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49287 }
49288 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49289 {
49290 PyThreadState* __tstate = wxPyBeginAllowThreads();
49291 result = (wxWindow *)(arg1)->GetWindow();
49292 wxPyEndAllowThreads(__tstate);
49293 if (PyErr_Occurred()) SWIG_fail;
49294 }
49295 {
49296 resultobj = wxPyMake_wxObject(result, 0);
49297 }
49298 return resultobj;
49299 fail:
49300 return NULL;
49301 }
49302
49303
49304 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49305 PyObject *resultobj = 0;
49306 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49307 wxWindow *arg2 = (wxWindow *) 0 ;
49308 void *argp1 = 0 ;
49309 int res1 = 0 ;
49310 void *argp2 = 0 ;
49311 int res2 = 0 ;
49312 PyObject * obj0 = 0 ;
49313 PyObject * obj1 = 0 ;
49314 char * kwnames[] = {
49315 (char *) "self",(char *) "window", NULL
49316 };
49317
49318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
49319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49320 if (!SWIG_IsOK(res1)) {
49321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49322 }
49323 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49324 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
49325 if (!SWIG_IsOK(res2)) {
49326 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
49327 }
49328 arg2 = reinterpret_cast< wxWindow * >(argp2);
49329 {
49330 PyThreadState* __tstate = wxPyBeginAllowThreads();
49331 (arg1)->SetWindow(arg2);
49332 wxPyEndAllowThreads(__tstate);
49333 if (PyErr_Occurred()) SWIG_fail;
49334 }
49335 resultobj = SWIG_Py_Void();
49336 return resultobj;
49337 fail:
49338 return NULL;
49339 }
49340
49341
49342 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49343 PyObject *resultobj = 0;
49344 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49345 wxSizer *result = 0 ;
49346 void *argp1 = 0 ;
49347 int res1 = 0 ;
49348 PyObject *swig_obj[1] ;
49349
49350 if (!args) SWIG_fail;
49351 swig_obj[0] = args;
49352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49353 if (!SWIG_IsOK(res1)) {
49354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49355 }
49356 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49357 {
49358 PyThreadState* __tstate = wxPyBeginAllowThreads();
49359 result = (wxSizer *)(arg1)->GetSizer();
49360 wxPyEndAllowThreads(__tstate);
49361 if (PyErr_Occurred()) SWIG_fail;
49362 }
49363 {
49364 resultobj = wxPyMake_wxObject(result, (bool)0);
49365 }
49366 return resultobj;
49367 fail:
49368 return NULL;
49369 }
49370
49371
49372 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49373 PyObject *resultobj = 0;
49374 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49375 wxSizer *arg2 = (wxSizer *) 0 ;
49376 void *argp1 = 0 ;
49377 int res1 = 0 ;
49378 int res2 = 0 ;
49379 PyObject * obj0 = 0 ;
49380 PyObject * obj1 = 0 ;
49381 char * kwnames[] = {
49382 (char *) "self",(char *) "sizer", NULL
49383 };
49384
49385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49387 if (!SWIG_IsOK(res1)) {
49388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49389 }
49390 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49391 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49392 if (!SWIG_IsOK(res2)) {
49393 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
49394 }
49395 {
49396 PyThreadState* __tstate = wxPyBeginAllowThreads();
49397 (arg1)->SetSizer(arg2);
49398 wxPyEndAllowThreads(__tstate);
49399 if (PyErr_Occurred()) SWIG_fail;
49400 }
49401 resultobj = SWIG_Py_Void();
49402 return resultobj;
49403 fail:
49404 return NULL;
49405 }
49406
49407
49408 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49409 PyObject *resultobj = 0;
49410 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49411 wxSize result;
49412 void *argp1 = 0 ;
49413 int res1 = 0 ;
49414 PyObject *swig_obj[1] ;
49415
49416 if (!args) SWIG_fail;
49417 swig_obj[0] = args;
49418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49419 if (!SWIG_IsOK(res1)) {
49420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49421 }
49422 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49423 {
49424 PyThreadState* __tstate = wxPyBeginAllowThreads();
49425 result = (arg1)->GetSpacer();
49426 wxPyEndAllowThreads(__tstate);
49427 if (PyErr_Occurred()) SWIG_fail;
49428 }
49429 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49430 return resultobj;
49431 fail:
49432 return NULL;
49433 }
49434
49435
49436 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49437 PyObject *resultobj = 0;
49438 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49439 wxSize *arg2 = 0 ;
49440 void *argp1 = 0 ;
49441 int res1 = 0 ;
49442 wxSize temp2 ;
49443 PyObject * obj0 = 0 ;
49444 PyObject * obj1 = 0 ;
49445 char * kwnames[] = {
49446 (char *) "self",(char *) "size", NULL
49447 };
49448
49449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
49450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49451 if (!SWIG_IsOK(res1)) {
49452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49453 }
49454 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49455 {
49456 arg2 = &temp2;
49457 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
49458 }
49459 {
49460 PyThreadState* __tstate = wxPyBeginAllowThreads();
49461 (arg1)->SetSpacer((wxSize const &)*arg2);
49462 wxPyEndAllowThreads(__tstate);
49463 if (PyErr_Occurred()) SWIG_fail;
49464 }
49465 resultobj = SWIG_Py_Void();
49466 return resultobj;
49467 fail:
49468 return NULL;
49469 }
49470
49471
49472 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49473 PyObject *resultobj = 0;
49474 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49475 bool arg2 ;
49476 void *argp1 = 0 ;
49477 int res1 = 0 ;
49478 bool val2 ;
49479 int ecode2 = 0 ;
49480 PyObject * obj0 = 0 ;
49481 PyObject * obj1 = 0 ;
49482 char * kwnames[] = {
49483 (char *) "self",(char *) "show", NULL
49484 };
49485
49486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
49487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49488 if (!SWIG_IsOK(res1)) {
49489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49490 }
49491 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49492 ecode2 = SWIG_AsVal_bool(obj1, &val2);
49493 if (!SWIG_IsOK(ecode2)) {
49494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
49495 }
49496 arg2 = static_cast< bool >(val2);
49497 {
49498 PyThreadState* __tstate = wxPyBeginAllowThreads();
49499 (arg1)->Show(arg2);
49500 wxPyEndAllowThreads(__tstate);
49501 if (PyErr_Occurred()) SWIG_fail;
49502 }
49503 resultobj = SWIG_Py_Void();
49504 return resultobj;
49505 fail:
49506 return NULL;
49507 }
49508
49509
49510 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49511 PyObject *resultobj = 0;
49512 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49513 bool result;
49514 void *argp1 = 0 ;
49515 int res1 = 0 ;
49516 PyObject *swig_obj[1] ;
49517
49518 if (!args) SWIG_fail;
49519 swig_obj[0] = args;
49520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49521 if (!SWIG_IsOK(res1)) {
49522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49523 }
49524 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49525 {
49526 PyThreadState* __tstate = wxPyBeginAllowThreads();
49527 result = (bool)(arg1)->IsShown();
49528 wxPyEndAllowThreads(__tstate);
49529 if (PyErr_Occurred()) SWIG_fail;
49530 }
49531 {
49532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49533 }
49534 return resultobj;
49535 fail:
49536 return NULL;
49537 }
49538
49539
49540 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49541 PyObject *resultobj = 0;
49542 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49543 wxPoint result;
49544 void *argp1 = 0 ;
49545 int res1 = 0 ;
49546 PyObject *swig_obj[1] ;
49547
49548 if (!args) SWIG_fail;
49549 swig_obj[0] = args;
49550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49551 if (!SWIG_IsOK(res1)) {
49552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49553 }
49554 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49555 {
49556 PyThreadState* __tstate = wxPyBeginAllowThreads();
49557 result = (arg1)->GetPosition();
49558 wxPyEndAllowThreads(__tstate);
49559 if (PyErr_Occurred()) SWIG_fail;
49560 }
49561 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
49562 return resultobj;
49563 fail:
49564 return NULL;
49565 }
49566
49567
49568 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49569 PyObject *resultobj = 0;
49570 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49571 PyObject *result = 0 ;
49572 void *argp1 = 0 ;
49573 int res1 = 0 ;
49574 PyObject *swig_obj[1] ;
49575
49576 if (!args) SWIG_fail;
49577 swig_obj[0] = args;
49578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49579 if (!SWIG_IsOK(res1)) {
49580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49581 }
49582 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49583 {
49584 PyThreadState* __tstate = wxPyBeginAllowThreads();
49585 result = (PyObject *)wxSizerItem_GetUserData(arg1);
49586 wxPyEndAllowThreads(__tstate);
49587 if (PyErr_Occurred()) SWIG_fail;
49588 }
49589 resultobj = result;
49590 return resultobj;
49591 fail:
49592 return NULL;
49593 }
49594
49595
49596 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49597 PyObject *resultobj = 0;
49598 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49599 PyObject *arg2 = (PyObject *) 0 ;
49600 void *argp1 = 0 ;
49601 int res1 = 0 ;
49602 PyObject * obj0 = 0 ;
49603 PyObject * obj1 = 0 ;
49604 char * kwnames[] = {
49605 (char *) "self",(char *) "userData", NULL
49606 };
49607
49608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
49609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49610 if (!SWIG_IsOK(res1)) {
49611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49612 }
49613 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49614 arg2 = obj1;
49615 {
49616 PyThreadState* __tstate = wxPyBeginAllowThreads();
49617 wxSizerItem_SetUserData(arg1,arg2);
49618 wxPyEndAllowThreads(__tstate);
49619 if (PyErr_Occurred()) SWIG_fail;
49620 }
49621 resultobj = SWIG_Py_Void();
49622 return resultobj;
49623 fail:
49624 return NULL;
49625 }
49626
49627
49628 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49629 PyObject *obj;
49630 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49631 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
49632 return SWIG_Py_Void();
49633 }
49634
49635 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49636 return SWIG_Python_InitShadowInstance(args);
49637 }
49638
49639 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49640 PyObject *resultobj = 0;
49641 wxSizer *arg1 = (wxSizer *) 0 ;
49642 void *argp1 = 0 ;
49643 int res1 = 0 ;
49644 PyObject *swig_obj[1] ;
49645
49646 if (!args) SWIG_fail;
49647 swig_obj[0] = args;
49648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49649 if (!SWIG_IsOK(res1)) {
49650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49651 }
49652 arg1 = reinterpret_cast< wxSizer * >(argp1);
49653 {
49654 PyThreadState* __tstate = wxPyBeginAllowThreads();
49655 delete arg1;
49656
49657 wxPyEndAllowThreads(__tstate);
49658 if (PyErr_Occurred()) SWIG_fail;
49659 }
49660 resultobj = SWIG_Py_Void();
49661 return resultobj;
49662 fail:
49663 return NULL;
49664 }
49665
49666
49667 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49668 PyObject *resultobj = 0;
49669 wxSizer *arg1 = (wxSizer *) 0 ;
49670 PyObject *arg2 = (PyObject *) 0 ;
49671 void *argp1 = 0 ;
49672 int res1 = 0 ;
49673 PyObject * obj0 = 0 ;
49674 PyObject * obj1 = 0 ;
49675 char * kwnames[] = {
49676 (char *) "self",(char *) "_self", NULL
49677 };
49678
49679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
49680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49681 if (!SWIG_IsOK(res1)) {
49682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
49683 }
49684 arg1 = reinterpret_cast< wxSizer * >(argp1);
49685 arg2 = obj1;
49686 {
49687 PyThreadState* __tstate = wxPyBeginAllowThreads();
49688 wxSizer__setOORInfo(arg1,arg2);
49689 wxPyEndAllowThreads(__tstate);
49690 if (PyErr_Occurred()) SWIG_fail;
49691 }
49692 resultobj = SWIG_Py_Void();
49693 return resultobj;
49694 fail:
49695 return NULL;
49696 }
49697
49698
49699 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49700 PyObject *resultobj = 0;
49701 wxSizer *arg1 = (wxSizer *) 0 ;
49702 PyObject *arg2 = (PyObject *) 0 ;
49703 int arg3 = (int) 0 ;
49704 int arg4 = (int) 0 ;
49705 int arg5 = (int) 0 ;
49706 PyObject *arg6 = (PyObject *) NULL ;
49707 wxSizerItem *result = 0 ;
49708 void *argp1 = 0 ;
49709 int res1 = 0 ;
49710 int val3 ;
49711 int ecode3 = 0 ;
49712 int val4 ;
49713 int ecode4 = 0 ;
49714 int val5 ;
49715 int ecode5 = 0 ;
49716 PyObject * obj0 = 0 ;
49717 PyObject * obj1 = 0 ;
49718 PyObject * obj2 = 0 ;
49719 PyObject * obj3 = 0 ;
49720 PyObject * obj4 = 0 ;
49721 PyObject * obj5 = 0 ;
49722 char * kwnames[] = {
49723 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49724 };
49725
49726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49728 if (!SWIG_IsOK(res1)) {
49729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
49730 }
49731 arg1 = reinterpret_cast< wxSizer * >(argp1);
49732 arg2 = obj1;
49733 if (obj2) {
49734 ecode3 = SWIG_AsVal_int(obj2, &val3);
49735 if (!SWIG_IsOK(ecode3)) {
49736 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
49737 }
49738 arg3 = static_cast< int >(val3);
49739 }
49740 if (obj3) {
49741 ecode4 = SWIG_AsVal_int(obj3, &val4);
49742 if (!SWIG_IsOK(ecode4)) {
49743 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
49744 }
49745 arg4 = static_cast< int >(val4);
49746 }
49747 if (obj4) {
49748 ecode5 = SWIG_AsVal_int(obj4, &val5);
49749 if (!SWIG_IsOK(ecode5)) {
49750 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
49751 }
49752 arg5 = static_cast< int >(val5);
49753 }
49754 if (obj5) {
49755 arg6 = obj5;
49756 }
49757 {
49758 PyThreadState* __tstate = wxPyBeginAllowThreads();
49759 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
49760 wxPyEndAllowThreads(__tstate);
49761 if (PyErr_Occurred()) SWIG_fail;
49762 }
49763 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49764 return resultobj;
49765 fail:
49766 return NULL;
49767 }
49768
49769
49770 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49771 PyObject *resultobj = 0;
49772 wxSizer *arg1 = (wxSizer *) 0 ;
49773 int arg2 ;
49774 PyObject *arg3 = (PyObject *) 0 ;
49775 int arg4 = (int) 0 ;
49776 int arg5 = (int) 0 ;
49777 int arg6 = (int) 0 ;
49778 PyObject *arg7 = (PyObject *) NULL ;
49779 wxSizerItem *result = 0 ;
49780 void *argp1 = 0 ;
49781 int res1 = 0 ;
49782 int val2 ;
49783 int ecode2 = 0 ;
49784 int val4 ;
49785 int ecode4 = 0 ;
49786 int val5 ;
49787 int ecode5 = 0 ;
49788 int val6 ;
49789 int ecode6 = 0 ;
49790 PyObject * obj0 = 0 ;
49791 PyObject * obj1 = 0 ;
49792 PyObject * obj2 = 0 ;
49793 PyObject * obj3 = 0 ;
49794 PyObject * obj4 = 0 ;
49795 PyObject * obj5 = 0 ;
49796 PyObject * obj6 = 0 ;
49797 char * kwnames[] = {
49798 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49799 };
49800
49801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49803 if (!SWIG_IsOK(res1)) {
49804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
49805 }
49806 arg1 = reinterpret_cast< wxSizer * >(argp1);
49807 ecode2 = SWIG_AsVal_int(obj1, &val2);
49808 if (!SWIG_IsOK(ecode2)) {
49809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
49810 }
49811 arg2 = static_cast< int >(val2);
49812 arg3 = obj2;
49813 if (obj3) {
49814 ecode4 = SWIG_AsVal_int(obj3, &val4);
49815 if (!SWIG_IsOK(ecode4)) {
49816 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
49817 }
49818 arg4 = static_cast< int >(val4);
49819 }
49820 if (obj4) {
49821 ecode5 = SWIG_AsVal_int(obj4, &val5);
49822 if (!SWIG_IsOK(ecode5)) {
49823 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
49824 }
49825 arg5 = static_cast< int >(val5);
49826 }
49827 if (obj5) {
49828 ecode6 = SWIG_AsVal_int(obj5, &val6);
49829 if (!SWIG_IsOK(ecode6)) {
49830 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
49831 }
49832 arg6 = static_cast< int >(val6);
49833 }
49834 if (obj6) {
49835 arg7 = obj6;
49836 }
49837 {
49838 PyThreadState* __tstate = wxPyBeginAllowThreads();
49839 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
49840 wxPyEndAllowThreads(__tstate);
49841 if (PyErr_Occurred()) SWIG_fail;
49842 }
49843 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49844 return resultobj;
49845 fail:
49846 return NULL;
49847 }
49848
49849
49850 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49851 PyObject *resultobj = 0;
49852 wxSizer *arg1 = (wxSizer *) 0 ;
49853 PyObject *arg2 = (PyObject *) 0 ;
49854 int arg3 = (int) 0 ;
49855 int arg4 = (int) 0 ;
49856 int arg5 = (int) 0 ;
49857 PyObject *arg6 = (PyObject *) NULL ;
49858 wxSizerItem *result = 0 ;
49859 void *argp1 = 0 ;
49860 int res1 = 0 ;
49861 int val3 ;
49862 int ecode3 = 0 ;
49863 int val4 ;
49864 int ecode4 = 0 ;
49865 int val5 ;
49866 int ecode5 = 0 ;
49867 PyObject * obj0 = 0 ;
49868 PyObject * obj1 = 0 ;
49869 PyObject * obj2 = 0 ;
49870 PyObject * obj3 = 0 ;
49871 PyObject * obj4 = 0 ;
49872 PyObject * obj5 = 0 ;
49873 char * kwnames[] = {
49874 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49875 };
49876
49877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49879 if (!SWIG_IsOK(res1)) {
49880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
49881 }
49882 arg1 = reinterpret_cast< wxSizer * >(argp1);
49883 arg2 = obj1;
49884 if (obj2) {
49885 ecode3 = SWIG_AsVal_int(obj2, &val3);
49886 if (!SWIG_IsOK(ecode3)) {
49887 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
49888 }
49889 arg3 = static_cast< int >(val3);
49890 }
49891 if (obj3) {
49892 ecode4 = SWIG_AsVal_int(obj3, &val4);
49893 if (!SWIG_IsOK(ecode4)) {
49894 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
49895 }
49896 arg4 = static_cast< int >(val4);
49897 }
49898 if (obj4) {
49899 ecode5 = SWIG_AsVal_int(obj4, &val5);
49900 if (!SWIG_IsOK(ecode5)) {
49901 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
49902 }
49903 arg5 = static_cast< int >(val5);
49904 }
49905 if (obj5) {
49906 arg6 = obj5;
49907 }
49908 {
49909 PyThreadState* __tstate = wxPyBeginAllowThreads();
49910 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
49911 wxPyEndAllowThreads(__tstate);
49912 if (PyErr_Occurred()) SWIG_fail;
49913 }
49914 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49915 return resultobj;
49916 fail:
49917 return NULL;
49918 }
49919
49920
49921 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49922 PyObject *resultobj = 0;
49923 wxSizer *arg1 = (wxSizer *) 0 ;
49924 PyObject *arg2 = (PyObject *) 0 ;
49925 bool result;
49926 void *argp1 = 0 ;
49927 int res1 = 0 ;
49928 PyObject * obj0 = 0 ;
49929 PyObject * obj1 = 0 ;
49930 char * kwnames[] = {
49931 (char *) "self",(char *) "item", NULL
49932 };
49933
49934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
49935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49936 if (!SWIG_IsOK(res1)) {
49937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
49938 }
49939 arg1 = reinterpret_cast< wxSizer * >(argp1);
49940 arg2 = obj1;
49941 {
49942 PyThreadState* __tstate = wxPyBeginAllowThreads();
49943 result = (bool)wxSizer_Remove(arg1,arg2);
49944 wxPyEndAllowThreads(__tstate);
49945 if (PyErr_Occurred()) SWIG_fail;
49946 }
49947 {
49948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49949 }
49950 return resultobj;
49951 fail:
49952 return NULL;
49953 }
49954
49955
49956 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49957 PyObject *resultobj = 0;
49958 wxSizer *arg1 = (wxSizer *) 0 ;
49959 PyObject *arg2 = (PyObject *) 0 ;
49960 bool result;
49961 void *argp1 = 0 ;
49962 int res1 = 0 ;
49963 PyObject * obj0 = 0 ;
49964 PyObject * obj1 = 0 ;
49965 char * kwnames[] = {
49966 (char *) "self",(char *) "item", NULL
49967 };
49968
49969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
49970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49971 if (!SWIG_IsOK(res1)) {
49972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
49973 }
49974 arg1 = reinterpret_cast< wxSizer * >(argp1);
49975 arg2 = obj1;
49976 {
49977 PyThreadState* __tstate = wxPyBeginAllowThreads();
49978 result = (bool)wxSizer_Detach(arg1,arg2);
49979 wxPyEndAllowThreads(__tstate);
49980 if (PyErr_Occurred()) SWIG_fail;
49981 }
49982 {
49983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49984 }
49985 return resultobj;
49986 fail:
49987 return NULL;
49988 }
49989
49990
49991 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49992 PyObject *resultobj = 0;
49993 wxSizer *arg1 = (wxSizer *) 0 ;
49994 PyObject *arg2 = (PyObject *) 0 ;
49995 wxSizerItem *result = 0 ;
49996 void *argp1 = 0 ;
49997 int res1 = 0 ;
49998 PyObject * obj0 = 0 ;
49999 PyObject * obj1 = 0 ;
50000 char * kwnames[] = {
50001 (char *) "self",(char *) "item", NULL
50002 };
50003
50004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
50005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50006 if (!SWIG_IsOK(res1)) {
50007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50008 }
50009 arg1 = reinterpret_cast< wxSizer * >(argp1);
50010 arg2 = obj1;
50011 {
50012 PyThreadState* __tstate = wxPyBeginAllowThreads();
50013 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
50014 wxPyEndAllowThreads(__tstate);
50015 if (PyErr_Occurred()) SWIG_fail;
50016 }
50017 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50018 return resultobj;
50019 fail:
50020 return NULL;
50021 }
50022
50023
50024 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50025 PyObject *resultobj = 0;
50026 wxSizer *arg1 = (wxSizer *) 0 ;
50027 PyObject *arg2 = (PyObject *) 0 ;
50028 wxSize *arg3 = 0 ;
50029 void *argp1 = 0 ;
50030 int res1 = 0 ;
50031 wxSize temp3 ;
50032 PyObject * obj0 = 0 ;
50033 PyObject * obj1 = 0 ;
50034 PyObject * obj2 = 0 ;
50035 char * kwnames[] = {
50036 (char *) "self",(char *) "item",(char *) "size", NULL
50037 };
50038
50039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50041 if (!SWIG_IsOK(res1)) {
50042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50043 }
50044 arg1 = reinterpret_cast< wxSizer * >(argp1);
50045 arg2 = obj1;
50046 {
50047 arg3 = &temp3;
50048 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
50049 }
50050 {
50051 PyThreadState* __tstate = wxPyBeginAllowThreads();
50052 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
50053 wxPyEndAllowThreads(__tstate);
50054 if (PyErr_Occurred()) SWIG_fail;
50055 }
50056 resultobj = SWIG_Py_Void();
50057 return resultobj;
50058 fail:
50059 return NULL;
50060 }
50061
50062
50063 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50064 PyObject *resultobj = 0;
50065 wxSizer *arg1 = (wxSizer *) 0 ;
50066 wxWindow *arg2 = (wxWindow *) 0 ;
50067 wxWindow *arg3 = (wxWindow *) 0 ;
50068 bool arg4 = (bool) false ;
50069 bool result;
50070 void *argp1 = 0 ;
50071 int res1 = 0 ;
50072 void *argp2 = 0 ;
50073 int res2 = 0 ;
50074 void *argp3 = 0 ;
50075 int res3 = 0 ;
50076 bool val4 ;
50077 int ecode4 = 0 ;
50078 PyObject * obj0 = 0 ;
50079 PyObject * obj1 = 0 ;
50080 PyObject * obj2 = 0 ;
50081 PyObject * obj3 = 0 ;
50082 char * kwnames[] = {
50083 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
50084 };
50085
50086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50088 if (!SWIG_IsOK(res1)) {
50089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
50090 }
50091 arg1 = reinterpret_cast< wxSizer * >(argp1);
50092 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50093 if (!SWIG_IsOK(res2)) {
50094 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
50095 }
50096 arg2 = reinterpret_cast< wxWindow * >(argp2);
50097 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
50098 if (!SWIG_IsOK(res3)) {
50099 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
50100 }
50101 arg3 = reinterpret_cast< wxWindow * >(argp3);
50102 if (obj3) {
50103 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50104 if (!SWIG_IsOK(ecode4)) {
50105 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
50106 }
50107 arg4 = static_cast< bool >(val4);
50108 }
50109 {
50110 PyThreadState* __tstate = wxPyBeginAllowThreads();
50111 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50112 wxPyEndAllowThreads(__tstate);
50113 if (PyErr_Occurred()) SWIG_fail;
50114 }
50115 {
50116 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50117 }
50118 return resultobj;
50119 fail:
50120 return NULL;
50121 }
50122
50123
50124 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50125 PyObject *resultobj = 0;
50126 wxSizer *arg1 = (wxSizer *) 0 ;
50127 wxSizer *arg2 = (wxSizer *) 0 ;
50128 wxSizer *arg3 = (wxSizer *) 0 ;
50129 bool arg4 = (bool) false ;
50130 bool result;
50131 void *argp1 = 0 ;
50132 int res1 = 0 ;
50133 void *argp2 = 0 ;
50134 int res2 = 0 ;
50135 void *argp3 = 0 ;
50136 int res3 = 0 ;
50137 bool val4 ;
50138 int ecode4 = 0 ;
50139 PyObject * obj0 = 0 ;
50140 PyObject * obj1 = 0 ;
50141 PyObject * obj2 = 0 ;
50142 PyObject * obj3 = 0 ;
50143 char * kwnames[] = {
50144 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
50145 };
50146
50147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50149 if (!SWIG_IsOK(res1)) {
50150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50151 }
50152 arg1 = reinterpret_cast< wxSizer * >(argp1);
50153 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50154 if (!SWIG_IsOK(res2)) {
50155 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
50156 }
50157 arg2 = reinterpret_cast< wxSizer * >(argp2);
50158 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
50159 if (!SWIG_IsOK(res3)) {
50160 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
50161 }
50162 arg3 = reinterpret_cast< wxSizer * >(argp3);
50163 if (obj3) {
50164 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50165 if (!SWIG_IsOK(ecode4)) {
50166 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
50167 }
50168 arg4 = static_cast< bool >(val4);
50169 }
50170 {
50171 PyThreadState* __tstate = wxPyBeginAllowThreads();
50172 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50173 wxPyEndAllowThreads(__tstate);
50174 if (PyErr_Occurred()) SWIG_fail;
50175 }
50176 {
50177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50178 }
50179 return resultobj;
50180 fail:
50181 return NULL;
50182 }
50183
50184
50185 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50186 PyObject *resultobj = 0;
50187 wxSizer *arg1 = (wxSizer *) 0 ;
50188 size_t arg2 ;
50189 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50190 bool result;
50191 void *argp1 = 0 ;
50192 int res1 = 0 ;
50193 size_t val2 ;
50194 int ecode2 = 0 ;
50195 void *argp3 = 0 ;
50196 int res3 = 0 ;
50197 PyObject * obj0 = 0 ;
50198 PyObject * obj1 = 0 ;
50199 PyObject * obj2 = 0 ;
50200 char * kwnames[] = {
50201 (char *) "self",(char *) "index",(char *) "newitem", NULL
50202 };
50203
50204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50206 if (!SWIG_IsOK(res1)) {
50207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50208 }
50209 arg1 = reinterpret_cast< wxSizer * >(argp1);
50210 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50211 if (!SWIG_IsOK(ecode2)) {
50212 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
50213 }
50214 arg2 = static_cast< size_t >(val2);
50215 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50216 if (!SWIG_IsOK(res3)) {
50217 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50218 }
50219 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
50220 {
50221 PyThreadState* __tstate = wxPyBeginAllowThreads();
50222 result = (bool)(arg1)->Replace(arg2,arg3);
50223 wxPyEndAllowThreads(__tstate);
50224 if (PyErr_Occurred()) SWIG_fail;
50225 }
50226 {
50227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50228 }
50229 return resultobj;
50230 fail:
50231 return NULL;
50232 }
50233
50234
50235 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50236 PyObject *resultobj = 0;
50237 wxSizer *arg1 = (wxSizer *) 0 ;
50238 wxWindow *arg2 = (wxWindow *) 0 ;
50239 void *argp1 = 0 ;
50240 int res1 = 0 ;
50241 void *argp2 = 0 ;
50242 int res2 = 0 ;
50243 PyObject * obj0 = 0 ;
50244 PyObject * obj1 = 0 ;
50245 char * kwnames[] = {
50246 (char *) "self",(char *) "window", NULL
50247 };
50248
50249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
50250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50251 if (!SWIG_IsOK(res1)) {
50252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
50253 }
50254 arg1 = reinterpret_cast< wxSizer * >(argp1);
50255 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50256 if (!SWIG_IsOK(res2)) {
50257 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
50258 }
50259 arg2 = reinterpret_cast< wxWindow * >(argp2);
50260 {
50261 PyThreadState* __tstate = wxPyBeginAllowThreads();
50262 (arg1)->SetContainingWindow(arg2);
50263 wxPyEndAllowThreads(__tstate);
50264 if (PyErr_Occurred()) SWIG_fail;
50265 }
50266 resultobj = SWIG_Py_Void();
50267 return resultobj;
50268 fail:
50269 return NULL;
50270 }
50271
50272
50273 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50274 PyObject *resultobj = 0;
50275 wxSizer *arg1 = (wxSizer *) 0 ;
50276 wxWindow *result = 0 ;
50277 void *argp1 = 0 ;
50278 int res1 = 0 ;
50279 PyObject *swig_obj[1] ;
50280
50281 if (!args) SWIG_fail;
50282 swig_obj[0] = args;
50283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50284 if (!SWIG_IsOK(res1)) {
50285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
50286 }
50287 arg1 = reinterpret_cast< wxSizer * >(argp1);
50288 {
50289 PyThreadState* __tstate = wxPyBeginAllowThreads();
50290 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
50291 wxPyEndAllowThreads(__tstate);
50292 if (PyErr_Occurred()) SWIG_fail;
50293 }
50294 {
50295 resultobj = wxPyMake_wxObject(result, 0);
50296 }
50297 return resultobj;
50298 fail:
50299 return NULL;
50300 }
50301
50302
50303 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50304 PyObject *resultobj = 0;
50305 wxSizer *arg1 = (wxSizer *) 0 ;
50306 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50307 wxSizerItem *result = 0 ;
50308 void *argp1 = 0 ;
50309 int res1 = 0 ;
50310 int res2 = 0 ;
50311 PyObject * obj0 = 0 ;
50312 PyObject * obj1 = 0 ;
50313 char * kwnames[] = {
50314 (char *) "self",(char *) "item", NULL
50315 };
50316
50317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50319 if (!SWIG_IsOK(res1)) {
50320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50321 }
50322 arg1 = reinterpret_cast< wxSizer * >(argp1);
50323 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50324 if (!SWIG_IsOK(res2)) {
50325 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50326 }
50327 {
50328 PyThreadState* __tstate = wxPyBeginAllowThreads();
50329 result = (wxSizerItem *)(arg1)->Add(arg2);
50330 wxPyEndAllowThreads(__tstate);
50331 if (PyErr_Occurred()) SWIG_fail;
50332 }
50333 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50334 return resultobj;
50335 fail:
50336 return NULL;
50337 }
50338
50339
50340 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50341 PyObject *resultobj = 0;
50342 wxSizer *arg1 = (wxSizer *) 0 ;
50343 size_t arg2 ;
50344 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50345 wxSizerItem *result = 0 ;
50346 void *argp1 = 0 ;
50347 int res1 = 0 ;
50348 size_t val2 ;
50349 int ecode2 = 0 ;
50350 int res3 = 0 ;
50351 PyObject * obj0 = 0 ;
50352 PyObject * obj1 = 0 ;
50353 PyObject * obj2 = 0 ;
50354 char * kwnames[] = {
50355 (char *) "self",(char *) "index",(char *) "item", NULL
50356 };
50357
50358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50360 if (!SWIG_IsOK(res1)) {
50361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50362 }
50363 arg1 = reinterpret_cast< wxSizer * >(argp1);
50364 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50365 if (!SWIG_IsOK(ecode2)) {
50366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
50367 }
50368 arg2 = static_cast< size_t >(val2);
50369 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50370 if (!SWIG_IsOK(res3)) {
50371 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50372 }
50373 {
50374 PyThreadState* __tstate = wxPyBeginAllowThreads();
50375 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
50376 wxPyEndAllowThreads(__tstate);
50377 if (PyErr_Occurred()) SWIG_fail;
50378 }
50379 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50380 return resultobj;
50381 fail:
50382 return NULL;
50383 }
50384
50385
50386 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50387 PyObject *resultobj = 0;
50388 wxSizer *arg1 = (wxSizer *) 0 ;
50389 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50390 wxSizerItem *result = 0 ;
50391 void *argp1 = 0 ;
50392 int res1 = 0 ;
50393 int res2 = 0 ;
50394 PyObject * obj0 = 0 ;
50395 PyObject * obj1 = 0 ;
50396 char * kwnames[] = {
50397 (char *) "self",(char *) "item", NULL
50398 };
50399
50400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
50401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50402 if (!SWIG_IsOK(res1)) {
50403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50404 }
50405 arg1 = reinterpret_cast< wxSizer * >(argp1);
50406 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50407 if (!SWIG_IsOK(res2)) {
50408 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50409 }
50410 {
50411 PyThreadState* __tstate = wxPyBeginAllowThreads();
50412 result = (wxSizerItem *)(arg1)->Prepend(arg2);
50413 wxPyEndAllowThreads(__tstate);
50414 if (PyErr_Occurred()) SWIG_fail;
50415 }
50416 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50417 return resultobj;
50418 fail:
50419 return NULL;
50420 }
50421
50422
50423 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50424 PyObject *resultobj = 0;
50425 wxSizer *arg1 = (wxSizer *) 0 ;
50426 int arg2 ;
50427 int arg3 ;
50428 int arg4 ;
50429 int arg5 ;
50430 void *argp1 = 0 ;
50431 int res1 = 0 ;
50432 int val2 ;
50433 int ecode2 = 0 ;
50434 int val3 ;
50435 int ecode3 = 0 ;
50436 int val4 ;
50437 int ecode4 = 0 ;
50438 int val5 ;
50439 int ecode5 = 0 ;
50440 PyObject * obj0 = 0 ;
50441 PyObject * obj1 = 0 ;
50442 PyObject * obj2 = 0 ;
50443 PyObject * obj3 = 0 ;
50444 PyObject * obj4 = 0 ;
50445 char * kwnames[] = {
50446 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
50447 };
50448
50449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
50450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50451 if (!SWIG_IsOK(res1)) {
50452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
50453 }
50454 arg1 = reinterpret_cast< wxSizer * >(argp1);
50455 ecode2 = SWIG_AsVal_int(obj1, &val2);
50456 if (!SWIG_IsOK(ecode2)) {
50457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
50458 }
50459 arg2 = static_cast< int >(val2);
50460 ecode3 = SWIG_AsVal_int(obj2, &val3);
50461 if (!SWIG_IsOK(ecode3)) {
50462 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
50463 }
50464 arg3 = static_cast< int >(val3);
50465 ecode4 = SWIG_AsVal_int(obj3, &val4);
50466 if (!SWIG_IsOK(ecode4)) {
50467 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
50468 }
50469 arg4 = static_cast< int >(val4);
50470 ecode5 = SWIG_AsVal_int(obj4, &val5);
50471 if (!SWIG_IsOK(ecode5)) {
50472 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
50473 }
50474 arg5 = static_cast< int >(val5);
50475 {
50476 PyThreadState* __tstate = wxPyBeginAllowThreads();
50477 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
50478 wxPyEndAllowThreads(__tstate);
50479 if (PyErr_Occurred()) SWIG_fail;
50480 }
50481 resultobj = SWIG_Py_Void();
50482 return resultobj;
50483 fail:
50484 return NULL;
50485 }
50486
50487
50488 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50489 PyObject *resultobj = 0;
50490 wxSizer *arg1 = (wxSizer *) 0 ;
50491 wxSize *arg2 = 0 ;
50492 void *argp1 = 0 ;
50493 int res1 = 0 ;
50494 wxSize temp2 ;
50495 PyObject * obj0 = 0 ;
50496 PyObject * obj1 = 0 ;
50497 char * kwnames[] = {
50498 (char *) "self",(char *) "size", NULL
50499 };
50500
50501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
50502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50503 if (!SWIG_IsOK(res1)) {
50504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50505 }
50506 arg1 = reinterpret_cast< wxSizer * >(argp1);
50507 {
50508 arg2 = &temp2;
50509 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50510 }
50511 {
50512 PyThreadState* __tstate = wxPyBeginAllowThreads();
50513 (arg1)->SetMinSize((wxSize const &)*arg2);
50514 wxPyEndAllowThreads(__tstate);
50515 if (PyErr_Occurred()) SWIG_fail;
50516 }
50517 resultobj = SWIG_Py_Void();
50518 return resultobj;
50519 fail:
50520 return NULL;
50521 }
50522
50523
50524 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50525 PyObject *resultobj = 0;
50526 wxSizer *arg1 = (wxSizer *) 0 ;
50527 wxSize result;
50528 void *argp1 = 0 ;
50529 int res1 = 0 ;
50530 PyObject *swig_obj[1] ;
50531
50532 if (!args) SWIG_fail;
50533 swig_obj[0] = args;
50534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50535 if (!SWIG_IsOK(res1)) {
50536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50537 }
50538 arg1 = reinterpret_cast< wxSizer * >(argp1);
50539 {
50540 PyThreadState* __tstate = wxPyBeginAllowThreads();
50541 result = (arg1)->GetSize();
50542 wxPyEndAllowThreads(__tstate);
50543 if (PyErr_Occurred()) SWIG_fail;
50544 }
50545 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50546 return resultobj;
50547 fail:
50548 return NULL;
50549 }
50550
50551
50552 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50553 PyObject *resultobj = 0;
50554 wxSizer *arg1 = (wxSizer *) 0 ;
50555 wxPoint result;
50556 void *argp1 = 0 ;
50557 int res1 = 0 ;
50558 PyObject *swig_obj[1] ;
50559
50560 if (!args) SWIG_fail;
50561 swig_obj[0] = args;
50562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50563 if (!SWIG_IsOK(res1)) {
50564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
50565 }
50566 arg1 = reinterpret_cast< wxSizer * >(argp1);
50567 {
50568 PyThreadState* __tstate = wxPyBeginAllowThreads();
50569 result = (arg1)->GetPosition();
50570 wxPyEndAllowThreads(__tstate);
50571 if (PyErr_Occurred()) SWIG_fail;
50572 }
50573 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
50574 return resultobj;
50575 fail:
50576 return NULL;
50577 }
50578
50579
50580 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50581 PyObject *resultobj = 0;
50582 wxSizer *arg1 = (wxSizer *) 0 ;
50583 wxSize result;
50584 void *argp1 = 0 ;
50585 int res1 = 0 ;
50586 PyObject *swig_obj[1] ;
50587
50588 if (!args) SWIG_fail;
50589 swig_obj[0] = args;
50590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50591 if (!SWIG_IsOK(res1)) {
50592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50593 }
50594 arg1 = reinterpret_cast< wxSizer * >(argp1);
50595 {
50596 PyThreadState* __tstate = wxPyBeginAllowThreads();
50597 result = (arg1)->GetMinSize();
50598 wxPyEndAllowThreads(__tstate);
50599 if (PyErr_Occurred()) SWIG_fail;
50600 }
50601 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50602 return resultobj;
50603 fail:
50604 return NULL;
50605 }
50606
50607
50608 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50609 PyObject *resultobj = 0;
50610 wxSizer *arg1 = (wxSizer *) 0 ;
50611 void *argp1 = 0 ;
50612 int res1 = 0 ;
50613 PyObject *swig_obj[1] ;
50614
50615 if (!args) SWIG_fail;
50616 swig_obj[0] = args;
50617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50618 if (!SWIG_IsOK(res1)) {
50619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
50620 }
50621 arg1 = reinterpret_cast< wxSizer * >(argp1);
50622 {
50623 PyThreadState* __tstate = wxPyBeginAllowThreads();
50624 (arg1)->RecalcSizes();
50625 wxPyEndAllowThreads(__tstate);
50626 if (PyErr_Occurred()) SWIG_fail;
50627 }
50628 resultobj = SWIG_Py_Void();
50629 return resultobj;
50630 fail:
50631 return NULL;
50632 }
50633
50634
50635 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50636 PyObject *resultobj = 0;
50637 wxSizer *arg1 = (wxSizer *) 0 ;
50638 wxSize result;
50639 void *argp1 = 0 ;
50640 int res1 = 0 ;
50641 PyObject *swig_obj[1] ;
50642
50643 if (!args) SWIG_fail;
50644 swig_obj[0] = args;
50645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50646 if (!SWIG_IsOK(res1)) {
50647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
50648 }
50649 arg1 = reinterpret_cast< wxSizer * >(argp1);
50650 {
50651 PyThreadState* __tstate = wxPyBeginAllowThreads();
50652 result = (arg1)->CalcMin();
50653 wxPyEndAllowThreads(__tstate);
50654 if (PyErr_Occurred()) SWIG_fail;
50655 }
50656 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50657 return resultobj;
50658 fail:
50659 return NULL;
50660 }
50661
50662
50663 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50664 PyObject *resultobj = 0;
50665 wxSizer *arg1 = (wxSizer *) 0 ;
50666 void *argp1 = 0 ;
50667 int res1 = 0 ;
50668 PyObject *swig_obj[1] ;
50669
50670 if (!args) SWIG_fail;
50671 swig_obj[0] = args;
50672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50673 if (!SWIG_IsOK(res1)) {
50674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
50675 }
50676 arg1 = reinterpret_cast< wxSizer * >(argp1);
50677 {
50678 PyThreadState* __tstate = wxPyBeginAllowThreads();
50679 (arg1)->Layout();
50680 wxPyEndAllowThreads(__tstate);
50681 if (PyErr_Occurred()) SWIG_fail;
50682 }
50683 resultobj = SWIG_Py_Void();
50684 return resultobj;
50685 fail:
50686 return NULL;
50687 }
50688
50689
50690 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50691 PyObject *resultobj = 0;
50692 wxSizer *arg1 = (wxSizer *) 0 ;
50693 wxWindow *arg2 = (wxWindow *) 0 ;
50694 wxSize result;
50695 void *argp1 = 0 ;
50696 int res1 = 0 ;
50697 void *argp2 = 0 ;
50698 int res2 = 0 ;
50699 PyObject * obj0 = 0 ;
50700 PyObject * obj1 = 0 ;
50701 char * kwnames[] = {
50702 (char *) "self",(char *) "window", NULL
50703 };
50704
50705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
50706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50707 if (!SWIG_IsOK(res1)) {
50708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
50709 }
50710 arg1 = reinterpret_cast< wxSizer * >(argp1);
50711 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50712 if (!SWIG_IsOK(res2)) {
50713 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
50714 }
50715 arg2 = reinterpret_cast< wxWindow * >(argp2);
50716 {
50717 PyThreadState* __tstate = wxPyBeginAllowThreads();
50718 result = (arg1)->Fit(arg2);
50719 wxPyEndAllowThreads(__tstate);
50720 if (PyErr_Occurred()) SWIG_fail;
50721 }
50722 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50723 return resultobj;
50724 fail:
50725 return NULL;
50726 }
50727
50728
50729 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50730 PyObject *resultobj = 0;
50731 wxSizer *arg1 = (wxSizer *) 0 ;
50732 wxWindow *arg2 = (wxWindow *) 0 ;
50733 void *argp1 = 0 ;
50734 int res1 = 0 ;
50735 void *argp2 = 0 ;
50736 int res2 = 0 ;
50737 PyObject * obj0 = 0 ;
50738 PyObject * obj1 = 0 ;
50739 char * kwnames[] = {
50740 (char *) "self",(char *) "window", NULL
50741 };
50742
50743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
50744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50745 if (!SWIG_IsOK(res1)) {
50746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
50747 }
50748 arg1 = reinterpret_cast< wxSizer * >(argp1);
50749 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50750 if (!SWIG_IsOK(res2)) {
50751 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
50752 }
50753 arg2 = reinterpret_cast< wxWindow * >(argp2);
50754 {
50755 PyThreadState* __tstate = wxPyBeginAllowThreads();
50756 (arg1)->FitInside(arg2);
50757 wxPyEndAllowThreads(__tstate);
50758 if (PyErr_Occurred()) SWIG_fail;
50759 }
50760 resultobj = SWIG_Py_Void();
50761 return resultobj;
50762 fail:
50763 return NULL;
50764 }
50765
50766
50767 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50768 PyObject *resultobj = 0;
50769 wxSizer *arg1 = (wxSizer *) 0 ;
50770 wxWindow *arg2 = (wxWindow *) 0 ;
50771 void *argp1 = 0 ;
50772 int res1 = 0 ;
50773 void *argp2 = 0 ;
50774 int res2 = 0 ;
50775 PyObject * obj0 = 0 ;
50776 PyObject * obj1 = 0 ;
50777 char * kwnames[] = {
50778 (char *) "self",(char *) "window", NULL
50779 };
50780
50781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
50782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50783 if (!SWIG_IsOK(res1)) {
50784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
50785 }
50786 arg1 = reinterpret_cast< wxSizer * >(argp1);
50787 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50788 if (!SWIG_IsOK(res2)) {
50789 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
50790 }
50791 arg2 = reinterpret_cast< wxWindow * >(argp2);
50792 {
50793 PyThreadState* __tstate = wxPyBeginAllowThreads();
50794 (arg1)->SetSizeHints(arg2);
50795 wxPyEndAllowThreads(__tstate);
50796 if (PyErr_Occurred()) SWIG_fail;
50797 }
50798 resultobj = SWIG_Py_Void();
50799 return resultobj;
50800 fail:
50801 return NULL;
50802 }
50803
50804
50805 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50806 PyObject *resultobj = 0;
50807 wxSizer *arg1 = (wxSizer *) 0 ;
50808 wxWindow *arg2 = (wxWindow *) 0 ;
50809 void *argp1 = 0 ;
50810 int res1 = 0 ;
50811 void *argp2 = 0 ;
50812 int res2 = 0 ;
50813 PyObject * obj0 = 0 ;
50814 PyObject * obj1 = 0 ;
50815 char * kwnames[] = {
50816 (char *) "self",(char *) "window", NULL
50817 };
50818
50819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
50820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50821 if (!SWIG_IsOK(res1)) {
50822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
50823 }
50824 arg1 = reinterpret_cast< wxSizer * >(argp1);
50825 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50826 if (!SWIG_IsOK(res2)) {
50827 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
50828 }
50829 arg2 = reinterpret_cast< wxWindow * >(argp2);
50830 {
50831 PyThreadState* __tstate = wxPyBeginAllowThreads();
50832 (arg1)->SetVirtualSizeHints(arg2);
50833 wxPyEndAllowThreads(__tstate);
50834 if (PyErr_Occurred()) SWIG_fail;
50835 }
50836 resultobj = SWIG_Py_Void();
50837 return resultobj;
50838 fail:
50839 return NULL;
50840 }
50841
50842
50843 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50844 PyObject *resultobj = 0;
50845 wxSizer *arg1 = (wxSizer *) 0 ;
50846 bool arg2 = (bool) false ;
50847 void *argp1 = 0 ;
50848 int res1 = 0 ;
50849 bool val2 ;
50850 int ecode2 = 0 ;
50851 PyObject * obj0 = 0 ;
50852 PyObject * obj1 = 0 ;
50853 char * kwnames[] = {
50854 (char *) "self",(char *) "deleteWindows", NULL
50855 };
50856
50857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
50858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50859 if (!SWIG_IsOK(res1)) {
50860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
50861 }
50862 arg1 = reinterpret_cast< wxSizer * >(argp1);
50863 if (obj1) {
50864 ecode2 = SWIG_AsVal_bool(obj1, &val2);
50865 if (!SWIG_IsOK(ecode2)) {
50866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
50867 }
50868 arg2 = static_cast< bool >(val2);
50869 }
50870 {
50871 PyThreadState* __tstate = wxPyBeginAllowThreads();
50872 (arg1)->Clear(arg2);
50873 wxPyEndAllowThreads(__tstate);
50874 if (PyErr_Occurred()) SWIG_fail;
50875 }
50876 resultobj = SWIG_Py_Void();
50877 return resultobj;
50878 fail:
50879 return NULL;
50880 }
50881
50882
50883 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50884 PyObject *resultobj = 0;
50885 wxSizer *arg1 = (wxSizer *) 0 ;
50886 void *argp1 = 0 ;
50887 int res1 = 0 ;
50888 PyObject *swig_obj[1] ;
50889
50890 if (!args) SWIG_fail;
50891 swig_obj[0] = args;
50892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50893 if (!SWIG_IsOK(res1)) {
50894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
50895 }
50896 arg1 = reinterpret_cast< wxSizer * >(argp1);
50897 {
50898 PyThreadState* __tstate = wxPyBeginAllowThreads();
50899 (arg1)->DeleteWindows();
50900 wxPyEndAllowThreads(__tstate);
50901 if (PyErr_Occurred()) SWIG_fail;
50902 }
50903 resultobj = SWIG_Py_Void();
50904 return resultobj;
50905 fail:
50906 return NULL;
50907 }
50908
50909
50910 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50911 PyObject *resultobj = 0;
50912 wxSizer *arg1 = (wxSizer *) 0 ;
50913 PyObject *result = 0 ;
50914 void *argp1 = 0 ;
50915 int res1 = 0 ;
50916 PyObject *swig_obj[1] ;
50917
50918 if (!args) SWIG_fail;
50919 swig_obj[0] = args;
50920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50921 if (!SWIG_IsOK(res1)) {
50922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
50923 }
50924 arg1 = reinterpret_cast< wxSizer * >(argp1);
50925 {
50926 PyThreadState* __tstate = wxPyBeginAllowThreads();
50927 result = (PyObject *)wxSizer_GetChildren(arg1);
50928 wxPyEndAllowThreads(__tstate);
50929 if (PyErr_Occurred()) SWIG_fail;
50930 }
50931 resultobj = result;
50932 return resultobj;
50933 fail:
50934 return NULL;
50935 }
50936
50937
50938 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50939 PyObject *resultobj = 0;
50940 wxSizer *arg1 = (wxSizer *) 0 ;
50941 PyObject *arg2 = (PyObject *) 0 ;
50942 bool arg3 = (bool) true ;
50943 bool arg4 = (bool) false ;
50944 bool result;
50945 void *argp1 = 0 ;
50946 int res1 = 0 ;
50947 bool val3 ;
50948 int ecode3 = 0 ;
50949 bool val4 ;
50950 int ecode4 = 0 ;
50951 PyObject * obj0 = 0 ;
50952 PyObject * obj1 = 0 ;
50953 PyObject * obj2 = 0 ;
50954 PyObject * obj3 = 0 ;
50955 char * kwnames[] = {
50956 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
50957 };
50958
50959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50961 if (!SWIG_IsOK(res1)) {
50962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
50963 }
50964 arg1 = reinterpret_cast< wxSizer * >(argp1);
50965 arg2 = obj1;
50966 if (obj2) {
50967 ecode3 = SWIG_AsVal_bool(obj2, &val3);
50968 if (!SWIG_IsOK(ecode3)) {
50969 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
50970 }
50971 arg3 = static_cast< bool >(val3);
50972 }
50973 if (obj3) {
50974 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50975 if (!SWIG_IsOK(ecode4)) {
50976 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
50977 }
50978 arg4 = static_cast< bool >(val4);
50979 }
50980 {
50981 PyThreadState* __tstate = wxPyBeginAllowThreads();
50982 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
50983 wxPyEndAllowThreads(__tstate);
50984 if (PyErr_Occurred()) SWIG_fail;
50985 }
50986 {
50987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50988 }
50989 return resultobj;
50990 fail:
50991 return NULL;
50992 }
50993
50994
50995 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50996 PyObject *resultobj = 0;
50997 wxSizer *arg1 = (wxSizer *) 0 ;
50998 PyObject *arg2 = (PyObject *) 0 ;
50999 bool result;
51000 void *argp1 = 0 ;
51001 int res1 = 0 ;
51002 PyObject * obj0 = 0 ;
51003 PyObject * obj1 = 0 ;
51004 char * kwnames[] = {
51005 (char *) "self",(char *) "item", NULL
51006 };
51007
51008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
51009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51010 if (!SWIG_IsOK(res1)) {
51011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
51012 }
51013 arg1 = reinterpret_cast< wxSizer * >(argp1);
51014 arg2 = obj1;
51015 {
51016 PyThreadState* __tstate = wxPyBeginAllowThreads();
51017 result = (bool)wxSizer_IsShown(arg1,arg2);
51018 wxPyEndAllowThreads(__tstate);
51019 if (PyErr_Occurred()) SWIG_fail;
51020 }
51021 {
51022 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51023 }
51024 return resultobj;
51025 fail:
51026 return NULL;
51027 }
51028
51029
51030 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51031 PyObject *resultobj = 0;
51032 wxSizer *arg1 = (wxSizer *) 0 ;
51033 bool arg2 ;
51034 void *argp1 = 0 ;
51035 int res1 = 0 ;
51036 bool val2 ;
51037 int ecode2 = 0 ;
51038 PyObject * obj0 = 0 ;
51039 PyObject * obj1 = 0 ;
51040 char * kwnames[] = {
51041 (char *) "self",(char *) "show", NULL
51042 };
51043
51044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
51045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51046 if (!SWIG_IsOK(res1)) {
51047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
51048 }
51049 arg1 = reinterpret_cast< wxSizer * >(argp1);
51050 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51051 if (!SWIG_IsOK(ecode2)) {
51052 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
51053 }
51054 arg2 = static_cast< bool >(val2);
51055 {
51056 PyThreadState* __tstate = wxPyBeginAllowThreads();
51057 (arg1)->ShowItems(arg2);
51058 wxPyEndAllowThreads(__tstate);
51059 if (PyErr_Occurred()) SWIG_fail;
51060 }
51061 resultobj = SWIG_Py_Void();
51062 return resultobj;
51063 fail:
51064 return NULL;
51065 }
51066
51067
51068 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51069 PyObject *obj;
51070 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51071 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
51072 return SWIG_Py_Void();
51073 }
51074
51075 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51076 PyObject *resultobj = 0;
51077 wxPySizer *result = 0 ;
51078
51079 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
51080 {
51081 PyThreadState* __tstate = wxPyBeginAllowThreads();
51082 result = (wxPySizer *)new wxPySizer();
51083 wxPyEndAllowThreads(__tstate);
51084 if (PyErr_Occurred()) SWIG_fail;
51085 }
51086 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
51087 return resultobj;
51088 fail:
51089 return NULL;
51090 }
51091
51092
51093 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51094 PyObject *resultobj = 0;
51095 wxPySizer *arg1 = (wxPySizer *) 0 ;
51096 PyObject *arg2 = (PyObject *) 0 ;
51097 PyObject *arg3 = (PyObject *) 0 ;
51098 void *argp1 = 0 ;
51099 int res1 = 0 ;
51100 PyObject * obj0 = 0 ;
51101 PyObject * obj1 = 0 ;
51102 PyObject * obj2 = 0 ;
51103 char * kwnames[] = {
51104 (char *) "self",(char *) "self",(char *) "_class", NULL
51105 };
51106
51107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
51109 if (!SWIG_IsOK(res1)) {
51110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
51111 }
51112 arg1 = reinterpret_cast< wxPySizer * >(argp1);
51113 arg2 = obj1;
51114 arg3 = obj2;
51115 {
51116 PyThreadState* __tstate = wxPyBeginAllowThreads();
51117 (arg1)->_setCallbackInfo(arg2,arg3);
51118 wxPyEndAllowThreads(__tstate);
51119 if (PyErr_Occurred()) SWIG_fail;
51120 }
51121 resultobj = SWIG_Py_Void();
51122 return resultobj;
51123 fail:
51124 return NULL;
51125 }
51126
51127
51128 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51129 PyObject *obj;
51130 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51131 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
51132 return SWIG_Py_Void();
51133 }
51134
51135 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51136 return SWIG_Python_InitShadowInstance(args);
51137 }
51138
51139 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51140 PyObject *resultobj = 0;
51141 int arg1 = (int) wxHORIZONTAL ;
51142 wxBoxSizer *result = 0 ;
51143 int val1 ;
51144 int ecode1 = 0 ;
51145 PyObject * obj0 = 0 ;
51146 char * kwnames[] = {
51147 (char *) "orient", NULL
51148 };
51149
51150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
51151 if (obj0) {
51152 ecode1 = SWIG_AsVal_int(obj0, &val1);
51153 if (!SWIG_IsOK(ecode1)) {
51154 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
51155 }
51156 arg1 = static_cast< int >(val1);
51157 }
51158 {
51159 PyThreadState* __tstate = wxPyBeginAllowThreads();
51160 result = (wxBoxSizer *)new wxBoxSizer(arg1);
51161 wxPyEndAllowThreads(__tstate);
51162 if (PyErr_Occurred()) SWIG_fail;
51163 }
51164 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
51165 return resultobj;
51166 fail:
51167 return NULL;
51168 }
51169
51170
51171 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51172 PyObject *resultobj = 0;
51173 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51174 int result;
51175 void *argp1 = 0 ;
51176 int res1 = 0 ;
51177 PyObject *swig_obj[1] ;
51178
51179 if (!args) SWIG_fail;
51180 swig_obj[0] = args;
51181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51182 if (!SWIG_IsOK(res1)) {
51183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51184 }
51185 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51186 {
51187 PyThreadState* __tstate = wxPyBeginAllowThreads();
51188 result = (int)(arg1)->GetOrientation();
51189 wxPyEndAllowThreads(__tstate);
51190 if (PyErr_Occurred()) SWIG_fail;
51191 }
51192 resultobj = SWIG_From_int(static_cast< int >(result));
51193 return resultobj;
51194 fail:
51195 return NULL;
51196 }
51197
51198
51199 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51200 PyObject *resultobj = 0;
51201 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51202 int arg2 ;
51203 void *argp1 = 0 ;
51204 int res1 = 0 ;
51205 int val2 ;
51206 int ecode2 = 0 ;
51207 PyObject * obj0 = 0 ;
51208 PyObject * obj1 = 0 ;
51209 char * kwnames[] = {
51210 (char *) "self",(char *) "orient", NULL
51211 };
51212
51213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
51214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51215 if (!SWIG_IsOK(res1)) {
51216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51217 }
51218 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51219 ecode2 = SWIG_AsVal_int(obj1, &val2);
51220 if (!SWIG_IsOK(ecode2)) {
51221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
51222 }
51223 arg2 = static_cast< int >(val2);
51224 {
51225 PyThreadState* __tstate = wxPyBeginAllowThreads();
51226 (arg1)->SetOrientation(arg2);
51227 wxPyEndAllowThreads(__tstate);
51228 if (PyErr_Occurred()) SWIG_fail;
51229 }
51230 resultobj = SWIG_Py_Void();
51231 return resultobj;
51232 fail:
51233 return NULL;
51234 }
51235
51236
51237 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51238 PyObject *obj;
51239 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51240 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
51241 return SWIG_Py_Void();
51242 }
51243
51244 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51245 return SWIG_Python_InitShadowInstance(args);
51246 }
51247
51248 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51249 PyObject *resultobj = 0;
51250 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
51251 int arg2 = (int) wxHORIZONTAL ;
51252 wxStaticBoxSizer *result = 0 ;
51253 void *argp1 = 0 ;
51254 int res1 = 0 ;
51255 int val2 ;
51256 int ecode2 = 0 ;
51257 PyObject * obj0 = 0 ;
51258 PyObject * obj1 = 0 ;
51259 char * kwnames[] = {
51260 (char *) "box",(char *) "orient", NULL
51261 };
51262
51263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
51265 if (!SWIG_IsOK(res1)) {
51266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
51267 }
51268 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
51269 if (obj1) {
51270 ecode2 = SWIG_AsVal_int(obj1, &val2);
51271 if (!SWIG_IsOK(ecode2)) {
51272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
51273 }
51274 arg2 = static_cast< int >(val2);
51275 }
51276 {
51277 PyThreadState* __tstate = wxPyBeginAllowThreads();
51278 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
51279 wxPyEndAllowThreads(__tstate);
51280 if (PyErr_Occurred()) SWIG_fail;
51281 }
51282 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
51283 return resultobj;
51284 fail:
51285 return NULL;
51286 }
51287
51288
51289 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51290 PyObject *resultobj = 0;
51291 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
51292 wxStaticBox *result = 0 ;
51293 void *argp1 = 0 ;
51294 int res1 = 0 ;
51295 PyObject *swig_obj[1] ;
51296
51297 if (!args) SWIG_fail;
51298 swig_obj[0] = args;
51299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
51300 if (!SWIG_IsOK(res1)) {
51301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
51302 }
51303 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
51304 {
51305 PyThreadState* __tstate = wxPyBeginAllowThreads();
51306 result = (wxStaticBox *)(arg1)->GetStaticBox();
51307 wxPyEndAllowThreads(__tstate);
51308 if (PyErr_Occurred()) SWIG_fail;
51309 }
51310 {
51311 resultobj = wxPyMake_wxObject(result, (bool)0);
51312 }
51313 return resultobj;
51314 fail:
51315 return NULL;
51316 }
51317
51318
51319 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51320 PyObject *obj;
51321 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51322 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
51323 return SWIG_Py_Void();
51324 }
51325
51326 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51327 return SWIG_Python_InitShadowInstance(args);
51328 }
51329
51330 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51331 PyObject *resultobj = 0;
51332 int arg1 = (int) 1 ;
51333 int arg2 = (int) 0 ;
51334 int arg3 = (int) 0 ;
51335 int arg4 = (int) 0 ;
51336 wxGridSizer *result = 0 ;
51337 int val1 ;
51338 int ecode1 = 0 ;
51339 int val2 ;
51340 int ecode2 = 0 ;
51341 int val3 ;
51342 int ecode3 = 0 ;
51343 int val4 ;
51344 int ecode4 = 0 ;
51345 PyObject * obj0 = 0 ;
51346 PyObject * obj1 = 0 ;
51347 PyObject * obj2 = 0 ;
51348 PyObject * obj3 = 0 ;
51349 char * kwnames[] = {
51350 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51351 };
51352
51353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51354 if (obj0) {
51355 ecode1 = SWIG_AsVal_int(obj0, &val1);
51356 if (!SWIG_IsOK(ecode1)) {
51357 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
51358 }
51359 arg1 = static_cast< int >(val1);
51360 }
51361 if (obj1) {
51362 ecode2 = SWIG_AsVal_int(obj1, &val2);
51363 if (!SWIG_IsOK(ecode2)) {
51364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
51365 }
51366 arg2 = static_cast< int >(val2);
51367 }
51368 if (obj2) {
51369 ecode3 = SWIG_AsVal_int(obj2, &val3);
51370 if (!SWIG_IsOK(ecode3)) {
51371 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
51372 }
51373 arg3 = static_cast< int >(val3);
51374 }
51375 if (obj3) {
51376 ecode4 = SWIG_AsVal_int(obj3, &val4);
51377 if (!SWIG_IsOK(ecode4)) {
51378 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
51379 }
51380 arg4 = static_cast< int >(val4);
51381 }
51382 {
51383 PyThreadState* __tstate = wxPyBeginAllowThreads();
51384 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
51385 wxPyEndAllowThreads(__tstate);
51386 if (PyErr_Occurred()) SWIG_fail;
51387 }
51388 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
51389 return resultobj;
51390 fail:
51391 return NULL;
51392 }
51393
51394
51395 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51396 PyObject *resultobj = 0;
51397 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51398 int arg2 ;
51399 void *argp1 = 0 ;
51400 int res1 = 0 ;
51401 int val2 ;
51402 int ecode2 = 0 ;
51403 PyObject * obj0 = 0 ;
51404 PyObject * obj1 = 0 ;
51405 char * kwnames[] = {
51406 (char *) "self",(char *) "cols", NULL
51407 };
51408
51409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
51410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51411 if (!SWIG_IsOK(res1)) {
51412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51413 }
51414 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51415 ecode2 = SWIG_AsVal_int(obj1, &val2);
51416 if (!SWIG_IsOK(ecode2)) {
51417 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
51418 }
51419 arg2 = static_cast< int >(val2);
51420 {
51421 PyThreadState* __tstate = wxPyBeginAllowThreads();
51422 (arg1)->SetCols(arg2);
51423 wxPyEndAllowThreads(__tstate);
51424 if (PyErr_Occurred()) SWIG_fail;
51425 }
51426 resultobj = SWIG_Py_Void();
51427 return resultobj;
51428 fail:
51429 return NULL;
51430 }
51431
51432
51433 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51434 PyObject *resultobj = 0;
51435 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51436 int arg2 ;
51437 void *argp1 = 0 ;
51438 int res1 = 0 ;
51439 int val2 ;
51440 int ecode2 = 0 ;
51441 PyObject * obj0 = 0 ;
51442 PyObject * obj1 = 0 ;
51443 char * kwnames[] = {
51444 (char *) "self",(char *) "rows", NULL
51445 };
51446
51447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
51448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51449 if (!SWIG_IsOK(res1)) {
51450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51451 }
51452 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51453 ecode2 = SWIG_AsVal_int(obj1, &val2);
51454 if (!SWIG_IsOK(ecode2)) {
51455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
51456 }
51457 arg2 = static_cast< int >(val2);
51458 {
51459 PyThreadState* __tstate = wxPyBeginAllowThreads();
51460 (arg1)->SetRows(arg2);
51461 wxPyEndAllowThreads(__tstate);
51462 if (PyErr_Occurred()) SWIG_fail;
51463 }
51464 resultobj = SWIG_Py_Void();
51465 return resultobj;
51466 fail:
51467 return NULL;
51468 }
51469
51470
51471 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51472 PyObject *resultobj = 0;
51473 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51474 int arg2 ;
51475 void *argp1 = 0 ;
51476 int res1 = 0 ;
51477 int val2 ;
51478 int ecode2 = 0 ;
51479 PyObject * obj0 = 0 ;
51480 PyObject * obj1 = 0 ;
51481 char * kwnames[] = {
51482 (char *) "self",(char *) "gap", NULL
51483 };
51484
51485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
51486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51487 if (!SWIG_IsOK(res1)) {
51488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51489 }
51490 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51491 ecode2 = SWIG_AsVal_int(obj1, &val2);
51492 if (!SWIG_IsOK(ecode2)) {
51493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
51494 }
51495 arg2 = static_cast< int >(val2);
51496 {
51497 PyThreadState* __tstate = wxPyBeginAllowThreads();
51498 (arg1)->SetVGap(arg2);
51499 wxPyEndAllowThreads(__tstate);
51500 if (PyErr_Occurred()) SWIG_fail;
51501 }
51502 resultobj = SWIG_Py_Void();
51503 return resultobj;
51504 fail:
51505 return NULL;
51506 }
51507
51508
51509 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51510 PyObject *resultobj = 0;
51511 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51512 int arg2 ;
51513 void *argp1 = 0 ;
51514 int res1 = 0 ;
51515 int val2 ;
51516 int ecode2 = 0 ;
51517 PyObject * obj0 = 0 ;
51518 PyObject * obj1 = 0 ;
51519 char * kwnames[] = {
51520 (char *) "self",(char *) "gap", NULL
51521 };
51522
51523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
51524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51525 if (!SWIG_IsOK(res1)) {
51526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51527 }
51528 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51529 ecode2 = SWIG_AsVal_int(obj1, &val2);
51530 if (!SWIG_IsOK(ecode2)) {
51531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
51532 }
51533 arg2 = static_cast< int >(val2);
51534 {
51535 PyThreadState* __tstate = wxPyBeginAllowThreads();
51536 (arg1)->SetHGap(arg2);
51537 wxPyEndAllowThreads(__tstate);
51538 if (PyErr_Occurred()) SWIG_fail;
51539 }
51540 resultobj = SWIG_Py_Void();
51541 return resultobj;
51542 fail:
51543 return NULL;
51544 }
51545
51546
51547 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51548 PyObject *resultobj = 0;
51549 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51550 int result;
51551 void *argp1 = 0 ;
51552 int res1 = 0 ;
51553 PyObject *swig_obj[1] ;
51554
51555 if (!args) SWIG_fail;
51556 swig_obj[0] = args;
51557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51558 if (!SWIG_IsOK(res1)) {
51559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51560 }
51561 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51562 {
51563 PyThreadState* __tstate = wxPyBeginAllowThreads();
51564 result = (int)(arg1)->GetCols();
51565 wxPyEndAllowThreads(__tstate);
51566 if (PyErr_Occurred()) SWIG_fail;
51567 }
51568 resultobj = SWIG_From_int(static_cast< int >(result));
51569 return resultobj;
51570 fail:
51571 return NULL;
51572 }
51573
51574
51575 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51576 PyObject *resultobj = 0;
51577 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51578 int result;
51579 void *argp1 = 0 ;
51580 int res1 = 0 ;
51581 PyObject *swig_obj[1] ;
51582
51583 if (!args) SWIG_fail;
51584 swig_obj[0] = args;
51585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51586 if (!SWIG_IsOK(res1)) {
51587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51588 }
51589 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51590 {
51591 PyThreadState* __tstate = wxPyBeginAllowThreads();
51592 result = (int)(arg1)->GetRows();
51593 wxPyEndAllowThreads(__tstate);
51594 if (PyErr_Occurred()) SWIG_fail;
51595 }
51596 resultobj = SWIG_From_int(static_cast< int >(result));
51597 return resultobj;
51598 fail:
51599 return NULL;
51600 }
51601
51602
51603 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51604 PyObject *resultobj = 0;
51605 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51606 int result;
51607 void *argp1 = 0 ;
51608 int res1 = 0 ;
51609 PyObject *swig_obj[1] ;
51610
51611 if (!args) SWIG_fail;
51612 swig_obj[0] = args;
51613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51614 if (!SWIG_IsOK(res1)) {
51615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51616 }
51617 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51618 {
51619 PyThreadState* __tstate = wxPyBeginAllowThreads();
51620 result = (int)(arg1)->GetVGap();
51621 wxPyEndAllowThreads(__tstate);
51622 if (PyErr_Occurred()) SWIG_fail;
51623 }
51624 resultobj = SWIG_From_int(static_cast< int >(result));
51625 return resultobj;
51626 fail:
51627 return NULL;
51628 }
51629
51630
51631 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51632 PyObject *resultobj = 0;
51633 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51634 int result;
51635 void *argp1 = 0 ;
51636 int res1 = 0 ;
51637 PyObject *swig_obj[1] ;
51638
51639 if (!args) SWIG_fail;
51640 swig_obj[0] = args;
51641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51642 if (!SWIG_IsOK(res1)) {
51643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51644 }
51645 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51646 {
51647 PyThreadState* __tstate = wxPyBeginAllowThreads();
51648 result = (int)(arg1)->GetHGap();
51649 wxPyEndAllowThreads(__tstate);
51650 if (PyErr_Occurred()) SWIG_fail;
51651 }
51652 resultobj = SWIG_From_int(static_cast< int >(result));
51653 return resultobj;
51654 fail:
51655 return NULL;
51656 }
51657
51658
51659 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51660 PyObject *obj;
51661 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51662 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
51663 return SWIG_Py_Void();
51664 }
51665
51666 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51667 return SWIG_Python_InitShadowInstance(args);
51668 }
51669
51670 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51671 PyObject *resultobj = 0;
51672 int arg1 = (int) 1 ;
51673 int arg2 = (int) 0 ;
51674 int arg3 = (int) 0 ;
51675 int arg4 = (int) 0 ;
51676 wxFlexGridSizer *result = 0 ;
51677 int val1 ;
51678 int ecode1 = 0 ;
51679 int val2 ;
51680 int ecode2 = 0 ;
51681 int val3 ;
51682 int ecode3 = 0 ;
51683 int val4 ;
51684 int ecode4 = 0 ;
51685 PyObject * obj0 = 0 ;
51686 PyObject * obj1 = 0 ;
51687 PyObject * obj2 = 0 ;
51688 PyObject * obj3 = 0 ;
51689 char * kwnames[] = {
51690 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51691 };
51692
51693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51694 if (obj0) {
51695 ecode1 = SWIG_AsVal_int(obj0, &val1);
51696 if (!SWIG_IsOK(ecode1)) {
51697 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
51698 }
51699 arg1 = static_cast< int >(val1);
51700 }
51701 if (obj1) {
51702 ecode2 = SWIG_AsVal_int(obj1, &val2);
51703 if (!SWIG_IsOK(ecode2)) {
51704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
51705 }
51706 arg2 = static_cast< int >(val2);
51707 }
51708 if (obj2) {
51709 ecode3 = SWIG_AsVal_int(obj2, &val3);
51710 if (!SWIG_IsOK(ecode3)) {
51711 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
51712 }
51713 arg3 = static_cast< int >(val3);
51714 }
51715 if (obj3) {
51716 ecode4 = SWIG_AsVal_int(obj3, &val4);
51717 if (!SWIG_IsOK(ecode4)) {
51718 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
51719 }
51720 arg4 = static_cast< int >(val4);
51721 }
51722 {
51723 PyThreadState* __tstate = wxPyBeginAllowThreads();
51724 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
51725 wxPyEndAllowThreads(__tstate);
51726 if (PyErr_Occurred()) SWIG_fail;
51727 }
51728 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
51729 return resultobj;
51730 fail:
51731 return NULL;
51732 }
51733
51734
51735 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51736 PyObject *resultobj = 0;
51737 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51738 size_t arg2 ;
51739 int arg3 = (int) 0 ;
51740 void *argp1 = 0 ;
51741 int res1 = 0 ;
51742 size_t val2 ;
51743 int ecode2 = 0 ;
51744 int val3 ;
51745 int ecode3 = 0 ;
51746 PyObject * obj0 = 0 ;
51747 PyObject * obj1 = 0 ;
51748 PyObject * obj2 = 0 ;
51749 char * kwnames[] = {
51750 (char *) "self",(char *) "idx",(char *) "proportion", NULL
51751 };
51752
51753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51755 if (!SWIG_IsOK(res1)) {
51756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51757 }
51758 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51759 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51760 if (!SWIG_IsOK(ecode2)) {
51761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
51762 }
51763 arg2 = static_cast< size_t >(val2);
51764 if (obj2) {
51765 ecode3 = SWIG_AsVal_int(obj2, &val3);
51766 if (!SWIG_IsOK(ecode3)) {
51767 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
51768 }
51769 arg3 = static_cast< int >(val3);
51770 }
51771 {
51772 PyThreadState* __tstate = wxPyBeginAllowThreads();
51773 (arg1)->AddGrowableRow(arg2,arg3);
51774 wxPyEndAllowThreads(__tstate);
51775 if (PyErr_Occurred()) SWIG_fail;
51776 }
51777 resultobj = SWIG_Py_Void();
51778 return resultobj;
51779 fail:
51780 return NULL;
51781 }
51782
51783
51784 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51785 PyObject *resultobj = 0;
51786 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51787 size_t arg2 ;
51788 void *argp1 = 0 ;
51789 int res1 = 0 ;
51790 size_t val2 ;
51791 int ecode2 = 0 ;
51792 PyObject * obj0 = 0 ;
51793 PyObject * obj1 = 0 ;
51794 char * kwnames[] = {
51795 (char *) "self",(char *) "idx", NULL
51796 };
51797
51798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
51799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51800 if (!SWIG_IsOK(res1)) {
51801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51802 }
51803 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51804 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51805 if (!SWIG_IsOK(ecode2)) {
51806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
51807 }
51808 arg2 = static_cast< size_t >(val2);
51809 {
51810 PyThreadState* __tstate = wxPyBeginAllowThreads();
51811 (arg1)->RemoveGrowableRow(arg2);
51812 wxPyEndAllowThreads(__tstate);
51813 if (PyErr_Occurred()) SWIG_fail;
51814 }
51815 resultobj = SWIG_Py_Void();
51816 return resultobj;
51817 fail:
51818 return NULL;
51819 }
51820
51821
51822 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51823 PyObject *resultobj = 0;
51824 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51825 size_t arg2 ;
51826 int arg3 = (int) 0 ;
51827 void *argp1 = 0 ;
51828 int res1 = 0 ;
51829 size_t val2 ;
51830 int ecode2 = 0 ;
51831 int val3 ;
51832 int ecode3 = 0 ;
51833 PyObject * obj0 = 0 ;
51834 PyObject * obj1 = 0 ;
51835 PyObject * obj2 = 0 ;
51836 char * kwnames[] = {
51837 (char *) "self",(char *) "idx",(char *) "proportion", NULL
51838 };
51839
51840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51842 if (!SWIG_IsOK(res1)) {
51843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51844 }
51845 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51846 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51847 if (!SWIG_IsOK(ecode2)) {
51848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
51849 }
51850 arg2 = static_cast< size_t >(val2);
51851 if (obj2) {
51852 ecode3 = SWIG_AsVal_int(obj2, &val3);
51853 if (!SWIG_IsOK(ecode3)) {
51854 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
51855 }
51856 arg3 = static_cast< int >(val3);
51857 }
51858 {
51859 PyThreadState* __tstate = wxPyBeginAllowThreads();
51860 (arg1)->AddGrowableCol(arg2,arg3);
51861 wxPyEndAllowThreads(__tstate);
51862 if (PyErr_Occurred()) SWIG_fail;
51863 }
51864 resultobj = SWIG_Py_Void();
51865 return resultobj;
51866 fail:
51867 return NULL;
51868 }
51869
51870
51871 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51872 PyObject *resultobj = 0;
51873 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51874 size_t arg2 ;
51875 void *argp1 = 0 ;
51876 int res1 = 0 ;
51877 size_t val2 ;
51878 int ecode2 = 0 ;
51879 PyObject * obj0 = 0 ;
51880 PyObject * obj1 = 0 ;
51881 char * kwnames[] = {
51882 (char *) "self",(char *) "idx", NULL
51883 };
51884
51885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
51886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51887 if (!SWIG_IsOK(res1)) {
51888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51889 }
51890 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51891 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51892 if (!SWIG_IsOK(ecode2)) {
51893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
51894 }
51895 arg2 = static_cast< size_t >(val2);
51896 {
51897 PyThreadState* __tstate = wxPyBeginAllowThreads();
51898 (arg1)->RemoveGrowableCol(arg2);
51899 wxPyEndAllowThreads(__tstate);
51900 if (PyErr_Occurred()) SWIG_fail;
51901 }
51902 resultobj = SWIG_Py_Void();
51903 return resultobj;
51904 fail:
51905 return NULL;
51906 }
51907
51908
51909 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51910 PyObject *resultobj = 0;
51911 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51912 int arg2 ;
51913 void *argp1 = 0 ;
51914 int res1 = 0 ;
51915 int val2 ;
51916 int ecode2 = 0 ;
51917 PyObject * obj0 = 0 ;
51918 PyObject * obj1 = 0 ;
51919 char * kwnames[] = {
51920 (char *) "self",(char *) "direction", NULL
51921 };
51922
51923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
51924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51925 if (!SWIG_IsOK(res1)) {
51926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51927 }
51928 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51929 ecode2 = SWIG_AsVal_int(obj1, &val2);
51930 if (!SWIG_IsOK(ecode2)) {
51931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
51932 }
51933 arg2 = static_cast< int >(val2);
51934 {
51935 PyThreadState* __tstate = wxPyBeginAllowThreads();
51936 (arg1)->SetFlexibleDirection(arg2);
51937 wxPyEndAllowThreads(__tstate);
51938 if (PyErr_Occurred()) SWIG_fail;
51939 }
51940 resultobj = SWIG_Py_Void();
51941 return resultobj;
51942 fail:
51943 return NULL;
51944 }
51945
51946
51947 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51948 PyObject *resultobj = 0;
51949 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51950 int result;
51951 void *argp1 = 0 ;
51952 int res1 = 0 ;
51953 PyObject *swig_obj[1] ;
51954
51955 if (!args) SWIG_fail;
51956 swig_obj[0] = args;
51957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51958 if (!SWIG_IsOK(res1)) {
51959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51960 }
51961 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51962 {
51963 PyThreadState* __tstate = wxPyBeginAllowThreads();
51964 result = (int)(arg1)->GetFlexibleDirection();
51965 wxPyEndAllowThreads(__tstate);
51966 if (PyErr_Occurred()) SWIG_fail;
51967 }
51968 resultobj = SWIG_From_int(static_cast< int >(result));
51969 return resultobj;
51970 fail:
51971 return NULL;
51972 }
51973
51974
51975 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51976 PyObject *resultobj = 0;
51977 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51978 wxFlexSizerGrowMode arg2 ;
51979 void *argp1 = 0 ;
51980 int res1 = 0 ;
51981 int val2 ;
51982 int ecode2 = 0 ;
51983 PyObject * obj0 = 0 ;
51984 PyObject * obj1 = 0 ;
51985 char * kwnames[] = {
51986 (char *) "self",(char *) "mode", NULL
51987 };
51988
51989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
51990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51991 if (!SWIG_IsOK(res1)) {
51992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51993 }
51994 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51995 ecode2 = SWIG_AsVal_int(obj1, &val2);
51996 if (!SWIG_IsOK(ecode2)) {
51997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
51998 }
51999 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
52000 {
52001 PyThreadState* __tstate = wxPyBeginAllowThreads();
52002 (arg1)->SetNonFlexibleGrowMode(arg2);
52003 wxPyEndAllowThreads(__tstate);
52004 if (PyErr_Occurred()) SWIG_fail;
52005 }
52006 resultobj = SWIG_Py_Void();
52007 return resultobj;
52008 fail:
52009 return NULL;
52010 }
52011
52012
52013 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52014 PyObject *resultobj = 0;
52015 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52016 wxFlexSizerGrowMode result;
52017 void *argp1 = 0 ;
52018 int res1 = 0 ;
52019 PyObject *swig_obj[1] ;
52020
52021 if (!args) SWIG_fail;
52022 swig_obj[0] = args;
52023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52024 if (!SWIG_IsOK(res1)) {
52025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52026 }
52027 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52028 {
52029 PyThreadState* __tstate = wxPyBeginAllowThreads();
52030 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
52031 wxPyEndAllowThreads(__tstate);
52032 if (PyErr_Occurred()) SWIG_fail;
52033 }
52034 resultobj = SWIG_From_int(static_cast< int >(result));
52035 return resultobj;
52036 fail:
52037 return NULL;
52038 }
52039
52040
52041 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52042 PyObject *resultobj = 0;
52043 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52044 wxArrayInt *result = 0 ;
52045 void *argp1 = 0 ;
52046 int res1 = 0 ;
52047 PyObject *swig_obj[1] ;
52048
52049 if (!args) SWIG_fail;
52050 swig_obj[0] = args;
52051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52052 if (!SWIG_IsOK(res1)) {
52053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52054 }
52055 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52056 {
52057 PyThreadState* __tstate = wxPyBeginAllowThreads();
52058 {
52059 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
52060 result = (wxArrayInt *) &_result_ref;
52061 }
52062 wxPyEndAllowThreads(__tstate);
52063 if (PyErr_Occurred()) SWIG_fail;
52064 }
52065 {
52066 resultobj = wxArrayInt2PyList_helper(*result);
52067 }
52068 return resultobj;
52069 fail:
52070 return NULL;
52071 }
52072
52073
52074 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52075 PyObject *resultobj = 0;
52076 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52077 wxArrayInt *result = 0 ;
52078 void *argp1 = 0 ;
52079 int res1 = 0 ;
52080 PyObject *swig_obj[1] ;
52081
52082 if (!args) SWIG_fail;
52083 swig_obj[0] = args;
52084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52085 if (!SWIG_IsOK(res1)) {
52086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52087 }
52088 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52089 {
52090 PyThreadState* __tstate = wxPyBeginAllowThreads();
52091 {
52092 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
52093 result = (wxArrayInt *) &_result_ref;
52094 }
52095 wxPyEndAllowThreads(__tstate);
52096 if (PyErr_Occurred()) SWIG_fail;
52097 }
52098 {
52099 resultobj = wxArrayInt2PyList_helper(*result);
52100 }
52101 return resultobj;
52102 fail:
52103 return NULL;
52104 }
52105
52106
52107 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52108 PyObject *obj;
52109 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52110 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
52111 return SWIG_Py_Void();
52112 }
52113
52114 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52115 return SWIG_Python_InitShadowInstance(args);
52116 }
52117
52118 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52119 PyObject *resultobj = 0;
52120 wxStdDialogButtonSizer *result = 0 ;
52121
52122 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
52123 {
52124 PyThreadState* __tstate = wxPyBeginAllowThreads();
52125 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
52126 wxPyEndAllowThreads(__tstate);
52127 if (PyErr_Occurred()) SWIG_fail;
52128 }
52129 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
52130 return resultobj;
52131 fail:
52132 return NULL;
52133 }
52134
52135
52136 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52137 PyObject *resultobj = 0;
52138 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52139 wxButton *arg2 = (wxButton *) 0 ;
52140 void *argp1 = 0 ;
52141 int res1 = 0 ;
52142 void *argp2 = 0 ;
52143 int res2 = 0 ;
52144 PyObject * obj0 = 0 ;
52145 PyObject * obj1 = 0 ;
52146 char * kwnames[] = {
52147 (char *) "self",(char *) "button", NULL
52148 };
52149
52150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
52151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52152 if (!SWIG_IsOK(res1)) {
52153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52154 }
52155 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52156 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52157 if (!SWIG_IsOK(res2)) {
52158 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
52159 }
52160 arg2 = reinterpret_cast< wxButton * >(argp2);
52161 {
52162 PyThreadState* __tstate = wxPyBeginAllowThreads();
52163 (arg1)->AddButton(arg2);
52164 wxPyEndAllowThreads(__tstate);
52165 if (PyErr_Occurred()) SWIG_fail;
52166 }
52167 resultobj = SWIG_Py_Void();
52168 return resultobj;
52169 fail:
52170 return NULL;
52171 }
52172
52173
52174 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52175 PyObject *resultobj = 0;
52176 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52177 void *argp1 = 0 ;
52178 int res1 = 0 ;
52179 PyObject *swig_obj[1] ;
52180
52181 if (!args) SWIG_fail;
52182 swig_obj[0] = args;
52183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52184 if (!SWIG_IsOK(res1)) {
52185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52186 }
52187 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52188 {
52189 PyThreadState* __tstate = wxPyBeginAllowThreads();
52190 (arg1)->Realize();
52191 wxPyEndAllowThreads(__tstate);
52192 if (PyErr_Occurred()) SWIG_fail;
52193 }
52194 resultobj = SWIG_Py_Void();
52195 return resultobj;
52196 fail:
52197 return NULL;
52198 }
52199
52200
52201 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52202 PyObject *resultobj = 0;
52203 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52204 wxButton *arg2 = (wxButton *) 0 ;
52205 void *argp1 = 0 ;
52206 int res1 = 0 ;
52207 void *argp2 = 0 ;
52208 int res2 = 0 ;
52209 PyObject * obj0 = 0 ;
52210 PyObject * obj1 = 0 ;
52211 char * kwnames[] = {
52212 (char *) "self",(char *) "button", NULL
52213 };
52214
52215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52217 if (!SWIG_IsOK(res1)) {
52218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52219 }
52220 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52221 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52222 if (!SWIG_IsOK(res2)) {
52223 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52224 }
52225 arg2 = reinterpret_cast< wxButton * >(argp2);
52226 {
52227 PyThreadState* __tstate = wxPyBeginAllowThreads();
52228 (arg1)->SetAffirmativeButton(arg2);
52229 wxPyEndAllowThreads(__tstate);
52230 if (PyErr_Occurred()) SWIG_fail;
52231 }
52232 resultobj = SWIG_Py_Void();
52233 return resultobj;
52234 fail:
52235 return NULL;
52236 }
52237
52238
52239 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52240 PyObject *resultobj = 0;
52241 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52242 wxButton *arg2 = (wxButton *) 0 ;
52243 void *argp1 = 0 ;
52244 int res1 = 0 ;
52245 void *argp2 = 0 ;
52246 int res2 = 0 ;
52247 PyObject * obj0 = 0 ;
52248 PyObject * obj1 = 0 ;
52249 char * kwnames[] = {
52250 (char *) "self",(char *) "button", NULL
52251 };
52252
52253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52255 if (!SWIG_IsOK(res1)) {
52256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52257 }
52258 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52259 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52260 if (!SWIG_IsOK(res2)) {
52261 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52262 }
52263 arg2 = reinterpret_cast< wxButton * >(argp2);
52264 {
52265 PyThreadState* __tstate = wxPyBeginAllowThreads();
52266 (arg1)->SetNegativeButton(arg2);
52267 wxPyEndAllowThreads(__tstate);
52268 if (PyErr_Occurred()) SWIG_fail;
52269 }
52270 resultobj = SWIG_Py_Void();
52271 return resultobj;
52272 fail:
52273 return NULL;
52274 }
52275
52276
52277 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52278 PyObject *resultobj = 0;
52279 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52280 wxButton *arg2 = (wxButton *) 0 ;
52281 void *argp1 = 0 ;
52282 int res1 = 0 ;
52283 void *argp2 = 0 ;
52284 int res2 = 0 ;
52285 PyObject * obj0 = 0 ;
52286 PyObject * obj1 = 0 ;
52287 char * kwnames[] = {
52288 (char *) "self",(char *) "button", NULL
52289 };
52290
52291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
52292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52293 if (!SWIG_IsOK(res1)) {
52294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52295 }
52296 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52297 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52298 if (!SWIG_IsOK(res2)) {
52299 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
52300 }
52301 arg2 = reinterpret_cast< wxButton * >(argp2);
52302 {
52303 PyThreadState* __tstate = wxPyBeginAllowThreads();
52304 (arg1)->SetCancelButton(arg2);
52305 wxPyEndAllowThreads(__tstate);
52306 if (PyErr_Occurred()) SWIG_fail;
52307 }
52308 resultobj = SWIG_Py_Void();
52309 return resultobj;
52310 fail:
52311 return NULL;
52312 }
52313
52314
52315 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52316 PyObject *resultobj = 0;
52317 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52318 wxButton *result = 0 ;
52319 void *argp1 = 0 ;
52320 int res1 = 0 ;
52321 PyObject *swig_obj[1] ;
52322
52323 if (!args) SWIG_fail;
52324 swig_obj[0] = args;
52325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52326 if (!SWIG_IsOK(res1)) {
52327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52328 }
52329 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52330 {
52331 PyThreadState* __tstate = wxPyBeginAllowThreads();
52332 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
52333 wxPyEndAllowThreads(__tstate);
52334 if (PyErr_Occurred()) SWIG_fail;
52335 }
52336 {
52337 resultobj = wxPyMake_wxObject(result, (bool)0);
52338 }
52339 return resultobj;
52340 fail:
52341 return NULL;
52342 }
52343
52344
52345 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52346 PyObject *resultobj = 0;
52347 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52348 wxButton *result = 0 ;
52349 void *argp1 = 0 ;
52350 int res1 = 0 ;
52351 PyObject *swig_obj[1] ;
52352
52353 if (!args) SWIG_fail;
52354 swig_obj[0] = args;
52355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52356 if (!SWIG_IsOK(res1)) {
52357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52358 }
52359 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52360 {
52361 PyThreadState* __tstate = wxPyBeginAllowThreads();
52362 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
52363 wxPyEndAllowThreads(__tstate);
52364 if (PyErr_Occurred()) SWIG_fail;
52365 }
52366 {
52367 resultobj = wxPyMake_wxObject(result, (bool)0);
52368 }
52369 return resultobj;
52370 fail:
52371 return NULL;
52372 }
52373
52374
52375 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52376 PyObject *resultobj = 0;
52377 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52378 wxButton *result = 0 ;
52379 void *argp1 = 0 ;
52380 int res1 = 0 ;
52381 PyObject *swig_obj[1] ;
52382
52383 if (!args) SWIG_fail;
52384 swig_obj[0] = args;
52385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52386 if (!SWIG_IsOK(res1)) {
52387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52388 }
52389 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52390 {
52391 PyThreadState* __tstate = wxPyBeginAllowThreads();
52392 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
52393 wxPyEndAllowThreads(__tstate);
52394 if (PyErr_Occurred()) SWIG_fail;
52395 }
52396 {
52397 resultobj = wxPyMake_wxObject(result, (bool)0);
52398 }
52399 return resultobj;
52400 fail:
52401 return NULL;
52402 }
52403
52404
52405 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52406 PyObject *resultobj = 0;
52407 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52408 wxButton *result = 0 ;
52409 void *argp1 = 0 ;
52410 int res1 = 0 ;
52411 PyObject *swig_obj[1] ;
52412
52413 if (!args) SWIG_fail;
52414 swig_obj[0] = args;
52415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52416 if (!SWIG_IsOK(res1)) {
52417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52418 }
52419 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52420 {
52421 PyThreadState* __tstate = wxPyBeginAllowThreads();
52422 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
52423 wxPyEndAllowThreads(__tstate);
52424 if (PyErr_Occurred()) SWIG_fail;
52425 }
52426 {
52427 resultobj = wxPyMake_wxObject(result, (bool)0);
52428 }
52429 return resultobj;
52430 fail:
52431 return NULL;
52432 }
52433
52434
52435 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52436 PyObject *resultobj = 0;
52437 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52438 wxButton *result = 0 ;
52439 void *argp1 = 0 ;
52440 int res1 = 0 ;
52441 PyObject *swig_obj[1] ;
52442
52443 if (!args) SWIG_fail;
52444 swig_obj[0] = args;
52445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52446 if (!SWIG_IsOK(res1)) {
52447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52448 }
52449 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52450 {
52451 PyThreadState* __tstate = wxPyBeginAllowThreads();
52452 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
52453 wxPyEndAllowThreads(__tstate);
52454 if (PyErr_Occurred()) SWIG_fail;
52455 }
52456 {
52457 resultobj = wxPyMake_wxObject(result, (bool)0);
52458 }
52459 return resultobj;
52460 fail:
52461 return NULL;
52462 }
52463
52464
52465 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52466 PyObject *obj;
52467 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52468 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
52469 return SWIG_Py_Void();
52470 }
52471
52472 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52473 return SWIG_Python_InitShadowInstance(args);
52474 }
52475
52476 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52477 PyObject *resultobj = 0;
52478 int arg1 = (int) 0 ;
52479 int arg2 = (int) 0 ;
52480 wxGBPosition *result = 0 ;
52481 int val1 ;
52482 int ecode1 = 0 ;
52483 int val2 ;
52484 int ecode2 = 0 ;
52485 PyObject * obj0 = 0 ;
52486 PyObject * obj1 = 0 ;
52487 char * kwnames[] = {
52488 (char *) "row",(char *) "col", NULL
52489 };
52490
52491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52492 if (obj0) {
52493 ecode1 = SWIG_AsVal_int(obj0, &val1);
52494 if (!SWIG_IsOK(ecode1)) {
52495 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
52496 }
52497 arg1 = static_cast< int >(val1);
52498 }
52499 if (obj1) {
52500 ecode2 = SWIG_AsVal_int(obj1, &val2);
52501 if (!SWIG_IsOK(ecode2)) {
52502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
52503 }
52504 arg2 = static_cast< int >(val2);
52505 }
52506 {
52507 PyThreadState* __tstate = wxPyBeginAllowThreads();
52508 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
52509 wxPyEndAllowThreads(__tstate);
52510 if (PyErr_Occurred()) SWIG_fail;
52511 }
52512 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
52513 return resultobj;
52514 fail:
52515 return NULL;
52516 }
52517
52518
52519 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52520 PyObject *resultobj = 0;
52521 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52522 void *argp1 = 0 ;
52523 int res1 = 0 ;
52524 PyObject *swig_obj[1] ;
52525
52526 if (!args) SWIG_fail;
52527 swig_obj[0] = args;
52528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
52529 if (!SWIG_IsOK(res1)) {
52530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52531 }
52532 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52533 {
52534 PyThreadState* __tstate = wxPyBeginAllowThreads();
52535 delete arg1;
52536
52537 wxPyEndAllowThreads(__tstate);
52538 if (PyErr_Occurred()) SWIG_fail;
52539 }
52540 resultobj = SWIG_Py_Void();
52541 return resultobj;
52542 fail:
52543 return NULL;
52544 }
52545
52546
52547 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52548 PyObject *resultobj = 0;
52549 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52550 int result;
52551 void *argp1 = 0 ;
52552 int res1 = 0 ;
52553 PyObject *swig_obj[1] ;
52554
52555 if (!args) SWIG_fail;
52556 swig_obj[0] = args;
52557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52558 if (!SWIG_IsOK(res1)) {
52559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52560 }
52561 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52562 {
52563 PyThreadState* __tstate = wxPyBeginAllowThreads();
52564 result = (int)((wxGBPosition const *)arg1)->GetRow();
52565 wxPyEndAllowThreads(__tstate);
52566 if (PyErr_Occurred()) SWIG_fail;
52567 }
52568 resultobj = SWIG_From_int(static_cast< int >(result));
52569 return resultobj;
52570 fail:
52571 return NULL;
52572 }
52573
52574
52575 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52576 PyObject *resultobj = 0;
52577 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52578 int result;
52579 void *argp1 = 0 ;
52580 int res1 = 0 ;
52581 PyObject *swig_obj[1] ;
52582
52583 if (!args) SWIG_fail;
52584 swig_obj[0] = args;
52585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52586 if (!SWIG_IsOK(res1)) {
52587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52588 }
52589 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52590 {
52591 PyThreadState* __tstate = wxPyBeginAllowThreads();
52592 result = (int)((wxGBPosition const *)arg1)->GetCol();
52593 wxPyEndAllowThreads(__tstate);
52594 if (PyErr_Occurred()) SWIG_fail;
52595 }
52596 resultobj = SWIG_From_int(static_cast< int >(result));
52597 return resultobj;
52598 fail:
52599 return NULL;
52600 }
52601
52602
52603 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52604 PyObject *resultobj = 0;
52605 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52606 int arg2 ;
52607 void *argp1 = 0 ;
52608 int res1 = 0 ;
52609 int val2 ;
52610 int ecode2 = 0 ;
52611 PyObject * obj0 = 0 ;
52612 PyObject * obj1 = 0 ;
52613 char * kwnames[] = {
52614 (char *) "self",(char *) "row", NULL
52615 };
52616
52617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
52618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52619 if (!SWIG_IsOK(res1)) {
52620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52621 }
52622 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52623 ecode2 = SWIG_AsVal_int(obj1, &val2);
52624 if (!SWIG_IsOK(ecode2)) {
52625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
52626 }
52627 arg2 = static_cast< int >(val2);
52628 {
52629 PyThreadState* __tstate = wxPyBeginAllowThreads();
52630 (arg1)->SetRow(arg2);
52631 wxPyEndAllowThreads(__tstate);
52632 if (PyErr_Occurred()) SWIG_fail;
52633 }
52634 resultobj = SWIG_Py_Void();
52635 return resultobj;
52636 fail:
52637 return NULL;
52638 }
52639
52640
52641 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52642 PyObject *resultobj = 0;
52643 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52644 int arg2 ;
52645 void *argp1 = 0 ;
52646 int res1 = 0 ;
52647 int val2 ;
52648 int ecode2 = 0 ;
52649 PyObject * obj0 = 0 ;
52650 PyObject * obj1 = 0 ;
52651 char * kwnames[] = {
52652 (char *) "self",(char *) "col", NULL
52653 };
52654
52655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
52656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52657 if (!SWIG_IsOK(res1)) {
52658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52659 }
52660 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52661 ecode2 = SWIG_AsVal_int(obj1, &val2);
52662 if (!SWIG_IsOK(ecode2)) {
52663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
52664 }
52665 arg2 = static_cast< int >(val2);
52666 {
52667 PyThreadState* __tstate = wxPyBeginAllowThreads();
52668 (arg1)->SetCol(arg2);
52669 wxPyEndAllowThreads(__tstate);
52670 if (PyErr_Occurred()) SWIG_fail;
52671 }
52672 resultobj = SWIG_Py_Void();
52673 return resultobj;
52674 fail:
52675 return NULL;
52676 }
52677
52678
52679 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52680 PyObject *resultobj = 0;
52681 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52682 PyObject *arg2 = (PyObject *) 0 ;
52683 bool result;
52684 void *argp1 = 0 ;
52685 int res1 = 0 ;
52686 PyObject * obj0 = 0 ;
52687 PyObject * obj1 = 0 ;
52688 char * kwnames[] = {
52689 (char *) "self",(char *) "other", NULL
52690 };
52691
52692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
52693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52694 if (!SWIG_IsOK(res1)) {
52695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52696 }
52697 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52698 arg2 = obj1;
52699 {
52700 result = (bool)wxGBPosition___eq__(arg1,arg2);
52701 if (PyErr_Occurred()) SWIG_fail;
52702 }
52703 {
52704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52705 }
52706 return resultobj;
52707 fail:
52708 return NULL;
52709 }
52710
52711
52712 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52713 PyObject *resultobj = 0;
52714 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52715 PyObject *arg2 = (PyObject *) 0 ;
52716 bool result;
52717 void *argp1 = 0 ;
52718 int res1 = 0 ;
52719 PyObject * obj0 = 0 ;
52720 PyObject * obj1 = 0 ;
52721 char * kwnames[] = {
52722 (char *) "self",(char *) "other", NULL
52723 };
52724
52725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
52726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52727 if (!SWIG_IsOK(res1)) {
52728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52729 }
52730 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52731 arg2 = obj1;
52732 {
52733 result = (bool)wxGBPosition___ne__(arg1,arg2);
52734 if (PyErr_Occurred()) SWIG_fail;
52735 }
52736 {
52737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52738 }
52739 return resultobj;
52740 fail:
52741 return NULL;
52742 }
52743
52744
52745 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52746 PyObject *resultobj = 0;
52747 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52748 int arg2 = (int) 0 ;
52749 int arg3 = (int) 0 ;
52750 void *argp1 = 0 ;
52751 int res1 = 0 ;
52752 int val2 ;
52753 int ecode2 = 0 ;
52754 int val3 ;
52755 int ecode3 = 0 ;
52756 PyObject * obj0 = 0 ;
52757 PyObject * obj1 = 0 ;
52758 PyObject * obj2 = 0 ;
52759 char * kwnames[] = {
52760 (char *) "self",(char *) "row",(char *) "col", NULL
52761 };
52762
52763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52765 if (!SWIG_IsOK(res1)) {
52766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52767 }
52768 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52769 if (obj1) {
52770 ecode2 = SWIG_AsVal_int(obj1, &val2);
52771 if (!SWIG_IsOK(ecode2)) {
52772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
52773 }
52774 arg2 = static_cast< int >(val2);
52775 }
52776 if (obj2) {
52777 ecode3 = SWIG_AsVal_int(obj2, &val3);
52778 if (!SWIG_IsOK(ecode3)) {
52779 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
52780 }
52781 arg3 = static_cast< int >(val3);
52782 }
52783 {
52784 PyThreadState* __tstate = wxPyBeginAllowThreads();
52785 wxGBPosition_Set(arg1,arg2,arg3);
52786 wxPyEndAllowThreads(__tstate);
52787 if (PyErr_Occurred()) SWIG_fail;
52788 }
52789 resultobj = SWIG_Py_Void();
52790 return resultobj;
52791 fail:
52792 return NULL;
52793 }
52794
52795
52796 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52797 PyObject *resultobj = 0;
52798 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52799 PyObject *result = 0 ;
52800 void *argp1 = 0 ;
52801 int res1 = 0 ;
52802 PyObject *swig_obj[1] ;
52803
52804 if (!args) SWIG_fail;
52805 swig_obj[0] = args;
52806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52807 if (!SWIG_IsOK(res1)) {
52808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52809 }
52810 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52811 {
52812 PyThreadState* __tstate = wxPyBeginAllowThreads();
52813 result = (PyObject *)wxGBPosition_Get(arg1);
52814 wxPyEndAllowThreads(__tstate);
52815 if (PyErr_Occurred()) SWIG_fail;
52816 }
52817 resultobj = result;
52818 return resultobj;
52819 fail:
52820 return NULL;
52821 }
52822
52823
52824 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52825 PyObject *obj;
52826 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52827 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
52828 return SWIG_Py_Void();
52829 }
52830
52831 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52832 return SWIG_Python_InitShadowInstance(args);
52833 }
52834
52835 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52836 PyObject *resultobj = 0;
52837 int arg1 = (int) 1 ;
52838 int arg2 = (int) 1 ;
52839 wxGBSpan *result = 0 ;
52840 int val1 ;
52841 int ecode1 = 0 ;
52842 int val2 ;
52843 int ecode2 = 0 ;
52844 PyObject * obj0 = 0 ;
52845 PyObject * obj1 = 0 ;
52846 char * kwnames[] = {
52847 (char *) "rowspan",(char *) "colspan", NULL
52848 };
52849
52850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
52851 if (obj0) {
52852 ecode1 = SWIG_AsVal_int(obj0, &val1);
52853 if (!SWIG_IsOK(ecode1)) {
52854 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
52855 }
52856 arg1 = static_cast< int >(val1);
52857 }
52858 if (obj1) {
52859 ecode2 = SWIG_AsVal_int(obj1, &val2);
52860 if (!SWIG_IsOK(ecode2)) {
52861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
52862 }
52863 arg2 = static_cast< int >(val2);
52864 }
52865 {
52866 PyThreadState* __tstate = wxPyBeginAllowThreads();
52867 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
52868 wxPyEndAllowThreads(__tstate);
52869 if (PyErr_Occurred()) SWIG_fail;
52870 }
52871 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
52872 return resultobj;
52873 fail:
52874 return NULL;
52875 }
52876
52877
52878 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52879 PyObject *resultobj = 0;
52880 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52881 void *argp1 = 0 ;
52882 int res1 = 0 ;
52883 PyObject *swig_obj[1] ;
52884
52885 if (!args) SWIG_fail;
52886 swig_obj[0] = args;
52887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
52888 if (!SWIG_IsOK(res1)) {
52889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
52890 }
52891 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
52892 {
52893 PyThreadState* __tstate = wxPyBeginAllowThreads();
52894 delete arg1;
52895
52896 wxPyEndAllowThreads(__tstate);
52897 if (PyErr_Occurred()) SWIG_fail;
52898 }
52899 resultobj = SWIG_Py_Void();
52900 return resultobj;
52901 fail:
52902 return NULL;
52903 }
52904
52905
52906 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52907 PyObject *resultobj = 0;
52908 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52909 int result;
52910 void *argp1 = 0 ;
52911 int res1 = 0 ;
52912 PyObject *swig_obj[1] ;
52913
52914 if (!args) SWIG_fail;
52915 swig_obj[0] = args;
52916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
52917 if (!SWIG_IsOK(res1)) {
52918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
52919 }
52920 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
52921 {
52922 PyThreadState* __tstate = wxPyBeginAllowThreads();
52923 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
52924 wxPyEndAllowThreads(__tstate);
52925 if (PyErr_Occurred()) SWIG_fail;
52926 }
52927 resultobj = SWIG_From_int(static_cast< int >(result));
52928 return resultobj;
52929 fail:
52930 return NULL;
52931 }
52932
52933
52934 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52935 PyObject *resultobj = 0;
52936 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52937 int result;
52938 void *argp1 = 0 ;
52939 int res1 = 0 ;
52940 PyObject *swig_obj[1] ;
52941
52942 if (!args) SWIG_fail;
52943 swig_obj[0] = args;
52944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
52945 if (!SWIG_IsOK(res1)) {
52946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
52947 }
52948 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
52949 {
52950 PyThreadState* __tstate = wxPyBeginAllowThreads();
52951 result = (int)((wxGBSpan const *)arg1)->GetColspan();
52952 wxPyEndAllowThreads(__tstate);
52953 if (PyErr_Occurred()) SWIG_fail;
52954 }
52955 resultobj = SWIG_From_int(static_cast< int >(result));
52956 return resultobj;
52957 fail:
52958 return NULL;
52959 }
52960
52961
52962 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52963 PyObject *resultobj = 0;
52964 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52965 int arg2 ;
52966 void *argp1 = 0 ;
52967 int res1 = 0 ;
52968 int val2 ;
52969 int ecode2 = 0 ;
52970 PyObject * obj0 = 0 ;
52971 PyObject * obj1 = 0 ;
52972 char * kwnames[] = {
52973 (char *) "self",(char *) "rowspan", NULL
52974 };
52975
52976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
52977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
52978 if (!SWIG_IsOK(res1)) {
52979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
52980 }
52981 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
52982 ecode2 = SWIG_AsVal_int(obj1, &val2);
52983 if (!SWIG_IsOK(ecode2)) {
52984 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
52985 }
52986 arg2 = static_cast< int >(val2);
52987 {
52988 PyThreadState* __tstate = wxPyBeginAllowThreads();
52989 (arg1)->SetRowspan(arg2);
52990 wxPyEndAllowThreads(__tstate);
52991 if (PyErr_Occurred()) SWIG_fail;
52992 }
52993 resultobj = SWIG_Py_Void();
52994 return resultobj;
52995 fail:
52996 return NULL;
52997 }
52998
52999
53000 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53001 PyObject *resultobj = 0;
53002 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53003 int arg2 ;
53004 void *argp1 = 0 ;
53005 int res1 = 0 ;
53006 int val2 ;
53007 int ecode2 = 0 ;
53008 PyObject * obj0 = 0 ;
53009 PyObject * obj1 = 0 ;
53010 char * kwnames[] = {
53011 (char *) "self",(char *) "colspan", NULL
53012 };
53013
53014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
53015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53016 if (!SWIG_IsOK(res1)) {
53017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53018 }
53019 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53020 ecode2 = SWIG_AsVal_int(obj1, &val2);
53021 if (!SWIG_IsOK(ecode2)) {
53022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
53023 }
53024 arg2 = static_cast< int >(val2);
53025 {
53026 PyThreadState* __tstate = wxPyBeginAllowThreads();
53027 (arg1)->SetColspan(arg2);
53028 wxPyEndAllowThreads(__tstate);
53029 if (PyErr_Occurred()) SWIG_fail;
53030 }
53031 resultobj = SWIG_Py_Void();
53032 return resultobj;
53033 fail:
53034 return NULL;
53035 }
53036
53037
53038 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53039 PyObject *resultobj = 0;
53040 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53041 PyObject *arg2 = (PyObject *) 0 ;
53042 bool result;
53043 void *argp1 = 0 ;
53044 int res1 = 0 ;
53045 PyObject * obj0 = 0 ;
53046 PyObject * obj1 = 0 ;
53047 char * kwnames[] = {
53048 (char *) "self",(char *) "other", NULL
53049 };
53050
53051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
53052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53053 if (!SWIG_IsOK(res1)) {
53054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53055 }
53056 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53057 arg2 = obj1;
53058 {
53059 result = (bool)wxGBSpan___eq__(arg1,arg2);
53060 if (PyErr_Occurred()) SWIG_fail;
53061 }
53062 {
53063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53064 }
53065 return resultobj;
53066 fail:
53067 return NULL;
53068 }
53069
53070
53071 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53072 PyObject *resultobj = 0;
53073 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53074 PyObject *arg2 = (PyObject *) 0 ;
53075 bool result;
53076 void *argp1 = 0 ;
53077 int res1 = 0 ;
53078 PyObject * obj0 = 0 ;
53079 PyObject * obj1 = 0 ;
53080 char * kwnames[] = {
53081 (char *) "self",(char *) "other", NULL
53082 };
53083
53084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
53085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53086 if (!SWIG_IsOK(res1)) {
53087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53088 }
53089 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53090 arg2 = obj1;
53091 {
53092 result = (bool)wxGBSpan___ne__(arg1,arg2);
53093 if (PyErr_Occurred()) SWIG_fail;
53094 }
53095 {
53096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53097 }
53098 return resultobj;
53099 fail:
53100 return NULL;
53101 }
53102
53103
53104 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53105 PyObject *resultobj = 0;
53106 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53107 int arg2 = (int) 1 ;
53108 int arg3 = (int) 1 ;
53109 void *argp1 = 0 ;
53110 int res1 = 0 ;
53111 int val2 ;
53112 int ecode2 = 0 ;
53113 int val3 ;
53114 int ecode3 = 0 ;
53115 PyObject * obj0 = 0 ;
53116 PyObject * obj1 = 0 ;
53117 PyObject * obj2 = 0 ;
53118 char * kwnames[] = {
53119 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
53120 };
53121
53122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53124 if (!SWIG_IsOK(res1)) {
53125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53126 }
53127 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53128 if (obj1) {
53129 ecode2 = SWIG_AsVal_int(obj1, &val2);
53130 if (!SWIG_IsOK(ecode2)) {
53131 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
53132 }
53133 arg2 = static_cast< int >(val2);
53134 }
53135 if (obj2) {
53136 ecode3 = SWIG_AsVal_int(obj2, &val3);
53137 if (!SWIG_IsOK(ecode3)) {
53138 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
53139 }
53140 arg3 = static_cast< int >(val3);
53141 }
53142 {
53143 PyThreadState* __tstate = wxPyBeginAllowThreads();
53144 wxGBSpan_Set(arg1,arg2,arg3);
53145 wxPyEndAllowThreads(__tstate);
53146 if (PyErr_Occurred()) SWIG_fail;
53147 }
53148 resultobj = SWIG_Py_Void();
53149 return resultobj;
53150 fail:
53151 return NULL;
53152 }
53153
53154
53155 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53156 PyObject *resultobj = 0;
53157 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53158 PyObject *result = 0 ;
53159 void *argp1 = 0 ;
53160 int res1 = 0 ;
53161 PyObject *swig_obj[1] ;
53162
53163 if (!args) SWIG_fail;
53164 swig_obj[0] = args;
53165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53166 if (!SWIG_IsOK(res1)) {
53167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53168 }
53169 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53170 {
53171 PyThreadState* __tstate = wxPyBeginAllowThreads();
53172 result = (PyObject *)wxGBSpan_Get(arg1);
53173 wxPyEndAllowThreads(__tstate);
53174 if (PyErr_Occurred()) SWIG_fail;
53175 }
53176 resultobj = result;
53177 return resultobj;
53178 fail:
53179 return NULL;
53180 }
53181
53182
53183 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53184 PyObject *obj;
53185 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53186 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
53187 return SWIG_Py_Void();
53188 }
53189
53190 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53191 return SWIG_Python_InitShadowInstance(args);
53192 }
53193
53194 SWIGINTERN int DefaultSpan_set(PyObject *) {
53195 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
53196 return 1;
53197 }
53198
53199
53200 SWIGINTERN PyObject *DefaultSpan_get(void) {
53201 PyObject *pyobj = 0;
53202
53203 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
53204 return pyobj;
53205 }
53206
53207
53208 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53209 PyObject *resultobj = 0;
53210 wxGBSizerItem *result = 0 ;
53211
53212 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
53213 {
53214 PyThreadState* __tstate = wxPyBeginAllowThreads();
53215 result = (wxGBSizerItem *)new wxGBSizerItem();
53216 wxPyEndAllowThreads(__tstate);
53217 if (PyErr_Occurred()) SWIG_fail;
53218 }
53219 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
53220 return resultobj;
53221 fail:
53222 return NULL;
53223 }
53224
53225
53226 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53227 PyObject *resultobj = 0;
53228 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53229 void *argp1 = 0 ;
53230 int res1 = 0 ;
53231 PyObject *swig_obj[1] ;
53232
53233 if (!args) SWIG_fail;
53234 swig_obj[0] = args;
53235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
53236 if (!SWIG_IsOK(res1)) {
53237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53238 }
53239 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53240 {
53241 PyThreadState* __tstate = wxPyBeginAllowThreads();
53242 delete arg1;
53243
53244 wxPyEndAllowThreads(__tstate);
53245 if (PyErr_Occurred()) SWIG_fail;
53246 }
53247 resultobj = SWIG_Py_Void();
53248 return resultobj;
53249 fail:
53250 return NULL;
53251 }
53252
53253
53254 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53255 PyObject *resultobj = 0;
53256 wxWindow *arg1 = (wxWindow *) 0 ;
53257 wxGBPosition *arg2 = 0 ;
53258 wxGBSpan *arg3 = 0 ;
53259 int arg4 ;
53260 int arg5 ;
53261 PyObject *arg6 = (PyObject *) NULL ;
53262 wxGBSizerItem *result = 0 ;
53263 void *argp1 = 0 ;
53264 int res1 = 0 ;
53265 wxGBPosition temp2 ;
53266 wxGBSpan temp3 ;
53267 int val4 ;
53268 int ecode4 = 0 ;
53269 int val5 ;
53270 int ecode5 = 0 ;
53271 PyObject * obj0 = 0 ;
53272 PyObject * obj1 = 0 ;
53273 PyObject * obj2 = 0 ;
53274 PyObject * obj3 = 0 ;
53275 PyObject * obj4 = 0 ;
53276 PyObject * obj5 = 0 ;
53277 char * kwnames[] = {
53278 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53279 };
53280
53281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
53283 if (!SWIG_IsOK(res1)) {
53284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
53285 }
53286 arg1 = reinterpret_cast< wxWindow * >(argp1);
53287 {
53288 arg2 = &temp2;
53289 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53290 }
53291 {
53292 arg3 = &temp3;
53293 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53294 }
53295 ecode4 = SWIG_AsVal_int(obj3, &val4);
53296 if (!SWIG_IsOK(ecode4)) {
53297 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
53298 }
53299 arg4 = static_cast< int >(val4);
53300 ecode5 = SWIG_AsVal_int(obj4, &val5);
53301 if (!SWIG_IsOK(ecode5)) {
53302 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
53303 }
53304 arg5 = static_cast< int >(val5);
53305 if (obj5) {
53306 arg6 = obj5;
53307 }
53308 {
53309 PyThreadState* __tstate = wxPyBeginAllowThreads();
53310 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53311 wxPyEndAllowThreads(__tstate);
53312 if (PyErr_Occurred()) SWIG_fail;
53313 }
53314 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53315 return resultobj;
53316 fail:
53317 return NULL;
53318 }
53319
53320
53321 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53322 PyObject *resultobj = 0;
53323 wxSizer *arg1 = (wxSizer *) 0 ;
53324 wxGBPosition *arg2 = 0 ;
53325 wxGBSpan *arg3 = 0 ;
53326 int arg4 ;
53327 int arg5 ;
53328 PyObject *arg6 = (PyObject *) NULL ;
53329 wxGBSizerItem *result = 0 ;
53330 int res1 = 0 ;
53331 wxGBPosition temp2 ;
53332 wxGBSpan temp3 ;
53333 int val4 ;
53334 int ecode4 = 0 ;
53335 int val5 ;
53336 int ecode5 = 0 ;
53337 PyObject * obj0 = 0 ;
53338 PyObject * obj1 = 0 ;
53339 PyObject * obj2 = 0 ;
53340 PyObject * obj3 = 0 ;
53341 PyObject * obj4 = 0 ;
53342 PyObject * obj5 = 0 ;
53343 char * kwnames[] = {
53344 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53345 };
53346
53347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53348 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
53349 if (!SWIG_IsOK(res1)) {
53350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
53351 }
53352 {
53353 arg2 = &temp2;
53354 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53355 }
53356 {
53357 arg3 = &temp3;
53358 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53359 }
53360 ecode4 = SWIG_AsVal_int(obj3, &val4);
53361 if (!SWIG_IsOK(ecode4)) {
53362 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
53363 }
53364 arg4 = static_cast< int >(val4);
53365 ecode5 = SWIG_AsVal_int(obj4, &val5);
53366 if (!SWIG_IsOK(ecode5)) {
53367 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
53368 }
53369 arg5 = static_cast< int >(val5);
53370 if (obj5) {
53371 arg6 = obj5;
53372 }
53373 {
53374 PyThreadState* __tstate = wxPyBeginAllowThreads();
53375 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53376 wxPyEndAllowThreads(__tstate);
53377 if (PyErr_Occurred()) SWIG_fail;
53378 }
53379 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53380 return resultobj;
53381 fail:
53382 return NULL;
53383 }
53384
53385
53386 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53387 PyObject *resultobj = 0;
53388 int arg1 ;
53389 int arg2 ;
53390 wxGBPosition *arg3 = 0 ;
53391 wxGBSpan *arg4 = 0 ;
53392 int arg5 ;
53393 int arg6 ;
53394 PyObject *arg7 = (PyObject *) NULL ;
53395 wxGBSizerItem *result = 0 ;
53396 int val1 ;
53397 int ecode1 = 0 ;
53398 int val2 ;
53399 int ecode2 = 0 ;
53400 wxGBPosition temp3 ;
53401 wxGBSpan temp4 ;
53402 int val5 ;
53403 int ecode5 = 0 ;
53404 int val6 ;
53405 int ecode6 = 0 ;
53406 PyObject * obj0 = 0 ;
53407 PyObject * obj1 = 0 ;
53408 PyObject * obj2 = 0 ;
53409 PyObject * obj3 = 0 ;
53410 PyObject * obj4 = 0 ;
53411 PyObject * obj5 = 0 ;
53412 PyObject * obj6 = 0 ;
53413 char * kwnames[] = {
53414 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53415 };
53416
53417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53418 ecode1 = SWIG_AsVal_int(obj0, &val1);
53419 if (!SWIG_IsOK(ecode1)) {
53420 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
53421 }
53422 arg1 = static_cast< int >(val1);
53423 ecode2 = SWIG_AsVal_int(obj1, &val2);
53424 if (!SWIG_IsOK(ecode2)) {
53425 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
53426 }
53427 arg2 = static_cast< int >(val2);
53428 {
53429 arg3 = &temp3;
53430 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53431 }
53432 {
53433 arg4 = &temp4;
53434 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
53435 }
53436 ecode5 = SWIG_AsVal_int(obj4, &val5);
53437 if (!SWIG_IsOK(ecode5)) {
53438 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
53439 }
53440 arg5 = static_cast< int >(val5);
53441 ecode6 = SWIG_AsVal_int(obj5, &val6);
53442 if (!SWIG_IsOK(ecode6)) {
53443 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
53444 }
53445 arg6 = static_cast< int >(val6);
53446 if (obj6) {
53447 arg7 = obj6;
53448 }
53449 {
53450 PyThreadState* __tstate = wxPyBeginAllowThreads();
53451 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
53452 wxPyEndAllowThreads(__tstate);
53453 if (PyErr_Occurred()) SWIG_fail;
53454 }
53455 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53456 return resultobj;
53457 fail:
53458 return NULL;
53459 }
53460
53461
53462 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53463 PyObject *resultobj = 0;
53464 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53465 wxGBPosition result;
53466 void *argp1 = 0 ;
53467 int res1 = 0 ;
53468 PyObject *swig_obj[1] ;
53469
53470 if (!args) SWIG_fail;
53471 swig_obj[0] = args;
53472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53473 if (!SWIG_IsOK(res1)) {
53474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53475 }
53476 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53477 {
53478 PyThreadState* __tstate = wxPyBeginAllowThreads();
53479 result = ((wxGBSizerItem const *)arg1)->GetPos();
53480 wxPyEndAllowThreads(__tstate);
53481 if (PyErr_Occurred()) SWIG_fail;
53482 }
53483 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53484 return resultobj;
53485 fail:
53486 return NULL;
53487 }
53488
53489
53490 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53491 PyObject *resultobj = 0;
53492 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53493 wxGBSpan result;
53494 void *argp1 = 0 ;
53495 int res1 = 0 ;
53496 PyObject *swig_obj[1] ;
53497
53498 if (!args) SWIG_fail;
53499 swig_obj[0] = args;
53500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53501 if (!SWIG_IsOK(res1)) {
53502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53503 }
53504 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53505 {
53506 PyThreadState* __tstate = wxPyBeginAllowThreads();
53507 result = ((wxGBSizerItem const *)arg1)->GetSpan();
53508 wxPyEndAllowThreads(__tstate);
53509 if (PyErr_Occurred()) SWIG_fail;
53510 }
53511 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
53512 return resultobj;
53513 fail:
53514 return NULL;
53515 }
53516
53517
53518 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53519 PyObject *resultobj = 0;
53520 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53521 wxGBPosition *arg2 = 0 ;
53522 bool result;
53523 void *argp1 = 0 ;
53524 int res1 = 0 ;
53525 wxGBPosition temp2 ;
53526 PyObject * obj0 = 0 ;
53527 PyObject * obj1 = 0 ;
53528 char * kwnames[] = {
53529 (char *) "self",(char *) "pos", NULL
53530 };
53531
53532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
53533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53534 if (!SWIG_IsOK(res1)) {
53535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53536 }
53537 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53538 {
53539 arg2 = &temp2;
53540 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53541 }
53542 {
53543 PyThreadState* __tstate = wxPyBeginAllowThreads();
53544 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
53545 wxPyEndAllowThreads(__tstate);
53546 if (PyErr_Occurred()) SWIG_fail;
53547 }
53548 {
53549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53550 }
53551 return resultobj;
53552 fail:
53553 return NULL;
53554 }
53555
53556
53557 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53558 PyObject *resultobj = 0;
53559 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53560 wxGBSpan *arg2 = 0 ;
53561 bool result;
53562 void *argp1 = 0 ;
53563 int res1 = 0 ;
53564 wxGBSpan temp2 ;
53565 PyObject * obj0 = 0 ;
53566 PyObject * obj1 = 0 ;
53567 char * kwnames[] = {
53568 (char *) "self",(char *) "span", NULL
53569 };
53570
53571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
53572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53573 if (!SWIG_IsOK(res1)) {
53574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53575 }
53576 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53577 {
53578 arg2 = &temp2;
53579 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
53580 }
53581 {
53582 PyThreadState* __tstate = wxPyBeginAllowThreads();
53583 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
53584 wxPyEndAllowThreads(__tstate);
53585 if (PyErr_Occurred()) SWIG_fail;
53586 }
53587 {
53588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53589 }
53590 return resultobj;
53591 fail:
53592 return NULL;
53593 }
53594
53595
53596 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53597 PyObject *resultobj = 0;
53598 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53599 wxGBSizerItem *arg2 = 0 ;
53600 bool result;
53601 void *argp1 = 0 ;
53602 int res1 = 0 ;
53603 void *argp2 = 0 ;
53604 int res2 = 0 ;
53605 PyObject * obj0 = 0 ;
53606 PyObject * obj1 = 0 ;
53607 char * kwnames[] = {
53608 (char *) "self",(char *) "other", NULL
53609 };
53610
53611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
53612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53613 if (!SWIG_IsOK(res1)) {
53614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53615 }
53616 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53617 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
53618 if (!SWIG_IsOK(res2)) {
53619 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53620 }
53621 if (!argp2) {
53622 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53623 }
53624 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
53625 {
53626 PyThreadState* __tstate = wxPyBeginAllowThreads();
53627 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
53628 wxPyEndAllowThreads(__tstate);
53629 if (PyErr_Occurred()) SWIG_fail;
53630 }
53631 {
53632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53633 }
53634 return resultobj;
53635 fail:
53636 return NULL;
53637 }
53638
53639
53640 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53641 PyObject *resultobj = 0;
53642 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53643 wxGBPosition *arg2 = 0 ;
53644 wxGBSpan *arg3 = 0 ;
53645 bool result;
53646 void *argp1 = 0 ;
53647 int res1 = 0 ;
53648 wxGBPosition temp2 ;
53649 wxGBSpan temp3 ;
53650 PyObject * obj0 = 0 ;
53651 PyObject * obj1 = 0 ;
53652 PyObject * obj2 = 0 ;
53653 char * kwnames[] = {
53654 (char *) "self",(char *) "pos",(char *) "span", NULL
53655 };
53656
53657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53659 if (!SWIG_IsOK(res1)) {
53660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53661 }
53662 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53663 {
53664 arg2 = &temp2;
53665 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53666 }
53667 {
53668 arg3 = &temp3;
53669 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53670 }
53671 {
53672 PyThreadState* __tstate = wxPyBeginAllowThreads();
53673 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
53674 wxPyEndAllowThreads(__tstate);
53675 if (PyErr_Occurred()) SWIG_fail;
53676 }
53677 {
53678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53679 }
53680 return resultobj;
53681 fail:
53682 return NULL;
53683 }
53684
53685
53686 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53687 PyObject *resultobj = 0;
53688 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53689 wxGBPosition result;
53690 void *argp1 = 0 ;
53691 int res1 = 0 ;
53692 PyObject *swig_obj[1] ;
53693
53694 if (!args) SWIG_fail;
53695 swig_obj[0] = args;
53696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53697 if (!SWIG_IsOK(res1)) {
53698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53699 }
53700 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53701 {
53702 PyThreadState* __tstate = wxPyBeginAllowThreads();
53703 result = wxGBSizerItem_GetEndPos(arg1);
53704 wxPyEndAllowThreads(__tstate);
53705 if (PyErr_Occurred()) SWIG_fail;
53706 }
53707 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53708 return resultobj;
53709 fail:
53710 return NULL;
53711 }
53712
53713
53714 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53715 PyObject *resultobj = 0;
53716 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53717 wxGridBagSizer *result = 0 ;
53718 void *argp1 = 0 ;
53719 int res1 = 0 ;
53720 PyObject *swig_obj[1] ;
53721
53722 if (!args) SWIG_fail;
53723 swig_obj[0] = args;
53724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53725 if (!SWIG_IsOK(res1)) {
53726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53727 }
53728 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53729 {
53730 PyThreadState* __tstate = wxPyBeginAllowThreads();
53731 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
53732 wxPyEndAllowThreads(__tstate);
53733 if (PyErr_Occurred()) SWIG_fail;
53734 }
53735 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53736 return resultobj;
53737 fail:
53738 return NULL;
53739 }
53740
53741
53742 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53743 PyObject *resultobj = 0;
53744 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53745 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
53746 void *argp1 = 0 ;
53747 int res1 = 0 ;
53748 void *argp2 = 0 ;
53749 int res2 = 0 ;
53750 PyObject * obj0 = 0 ;
53751 PyObject * obj1 = 0 ;
53752 char * kwnames[] = {
53753 (char *) "self",(char *) "sizer", NULL
53754 };
53755
53756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53758 if (!SWIG_IsOK(res1)) {
53759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53760 }
53761 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53762 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53763 if (!SWIG_IsOK(res2)) {
53764 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
53765 }
53766 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
53767 {
53768 PyThreadState* __tstate = wxPyBeginAllowThreads();
53769 (arg1)->SetGBSizer(arg2);
53770 wxPyEndAllowThreads(__tstate);
53771 if (PyErr_Occurred()) SWIG_fail;
53772 }
53773 resultobj = SWIG_Py_Void();
53774 return resultobj;
53775 fail:
53776 return NULL;
53777 }
53778
53779
53780 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53781 PyObject *obj;
53782 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53783 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
53784 return SWIG_Py_Void();
53785 }
53786
53787 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53788 return SWIG_Python_InitShadowInstance(args);
53789 }
53790
53791 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53792 PyObject *resultobj = 0;
53793 int arg1 = (int) 0 ;
53794 int arg2 = (int) 0 ;
53795 wxGridBagSizer *result = 0 ;
53796 int val1 ;
53797 int ecode1 = 0 ;
53798 int val2 ;
53799 int ecode2 = 0 ;
53800 PyObject * obj0 = 0 ;
53801 PyObject * obj1 = 0 ;
53802 char * kwnames[] = {
53803 (char *) "vgap",(char *) "hgap", NULL
53804 };
53805
53806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53807 if (obj0) {
53808 ecode1 = SWIG_AsVal_int(obj0, &val1);
53809 if (!SWIG_IsOK(ecode1)) {
53810 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
53811 }
53812 arg1 = static_cast< int >(val1);
53813 }
53814 if (obj1) {
53815 ecode2 = SWIG_AsVal_int(obj1, &val2);
53816 if (!SWIG_IsOK(ecode2)) {
53817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
53818 }
53819 arg2 = static_cast< int >(val2);
53820 }
53821 {
53822 PyThreadState* __tstate = wxPyBeginAllowThreads();
53823 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
53824 wxPyEndAllowThreads(__tstate);
53825 if (PyErr_Occurred()) SWIG_fail;
53826 }
53827 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
53828 return resultobj;
53829 fail:
53830 return NULL;
53831 }
53832
53833
53834 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53835 PyObject *resultobj = 0;
53836 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53837 PyObject *arg2 = (PyObject *) 0 ;
53838 wxGBPosition *arg3 = 0 ;
53839 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
53840 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
53841 int arg5 = (int) 0 ;
53842 int arg6 = (int) 0 ;
53843 PyObject *arg7 = (PyObject *) NULL ;
53844 wxGBSizerItem *result = 0 ;
53845 void *argp1 = 0 ;
53846 int res1 = 0 ;
53847 wxGBPosition temp3 ;
53848 wxGBSpan temp4 ;
53849 int val5 ;
53850 int ecode5 = 0 ;
53851 int val6 ;
53852 int ecode6 = 0 ;
53853 PyObject * obj0 = 0 ;
53854 PyObject * obj1 = 0 ;
53855 PyObject * obj2 = 0 ;
53856 PyObject * obj3 = 0 ;
53857 PyObject * obj4 = 0 ;
53858 PyObject * obj5 = 0 ;
53859 PyObject * obj6 = 0 ;
53860 char * kwnames[] = {
53861 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53862 };
53863
53864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53866 if (!SWIG_IsOK(res1)) {
53867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
53868 }
53869 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
53870 arg2 = obj1;
53871 {
53872 arg3 = &temp3;
53873 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53874 }
53875 if (obj3) {
53876 {
53877 arg4 = &temp4;
53878 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
53879 }
53880 }
53881 if (obj4) {
53882 ecode5 = SWIG_AsVal_int(obj4, &val5);
53883 if (!SWIG_IsOK(ecode5)) {
53884 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
53885 }
53886 arg5 = static_cast< int >(val5);
53887 }
53888 if (obj5) {
53889 ecode6 = SWIG_AsVal_int(obj5, &val6);
53890 if (!SWIG_IsOK(ecode6)) {
53891 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
53892 }
53893 arg6 = static_cast< int >(val6);
53894 }
53895 if (obj6) {
53896 arg7 = obj6;
53897 }
53898 {
53899 PyThreadState* __tstate = wxPyBeginAllowThreads();
53900 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
53901 wxPyEndAllowThreads(__tstate);
53902 if (PyErr_Occurred()) SWIG_fail;
53903 }
53904 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53905 return resultobj;
53906 fail:
53907 return NULL;
53908 }
53909
53910
53911 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53912 PyObject *resultobj = 0;
53913 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53914 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
53915 wxGBSizerItem *result = 0 ;
53916 void *argp1 = 0 ;
53917 int res1 = 0 ;
53918 int res2 = 0 ;
53919 PyObject * obj0 = 0 ;
53920 PyObject * obj1 = 0 ;
53921 char * kwnames[] = {
53922 (char *) "self",(char *) "item", NULL
53923 };
53924
53925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
53926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53927 if (!SWIG_IsOK(res1)) {
53928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
53929 }
53930 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
53931 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
53932 if (!SWIG_IsOK(res2)) {
53933 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
53934 }
53935 {
53936 PyThreadState* __tstate = wxPyBeginAllowThreads();
53937 result = (wxGBSizerItem *)(arg1)->Add(arg2);
53938 wxPyEndAllowThreads(__tstate);
53939 if (PyErr_Occurred()) SWIG_fail;
53940 }
53941 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53942 return resultobj;
53943 fail:
53944 return NULL;
53945 }
53946
53947
53948 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53949 PyObject *resultobj = 0;
53950 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53951 int arg2 ;
53952 int arg3 ;
53953 wxSize result;
53954 void *argp1 = 0 ;
53955 int res1 = 0 ;
53956 int val2 ;
53957 int ecode2 = 0 ;
53958 int val3 ;
53959 int ecode3 = 0 ;
53960 PyObject * obj0 = 0 ;
53961 PyObject * obj1 = 0 ;
53962 PyObject * obj2 = 0 ;
53963 char * kwnames[] = {
53964 (char *) "self",(char *) "row",(char *) "col", NULL
53965 };
53966
53967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53969 if (!SWIG_IsOK(res1)) {
53970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
53971 }
53972 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
53973 ecode2 = SWIG_AsVal_int(obj1, &val2);
53974 if (!SWIG_IsOK(ecode2)) {
53975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
53976 }
53977 arg2 = static_cast< int >(val2);
53978 ecode3 = SWIG_AsVal_int(obj2, &val3);
53979 if (!SWIG_IsOK(ecode3)) {
53980 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
53981 }
53982 arg3 = static_cast< int >(val3);
53983 {
53984 PyThreadState* __tstate = wxPyBeginAllowThreads();
53985 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
53986 wxPyEndAllowThreads(__tstate);
53987 if (PyErr_Occurred()) SWIG_fail;
53988 }
53989 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
53990 return resultobj;
53991 fail:
53992 return NULL;
53993 }
53994
53995
53996 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53997 PyObject *resultobj = 0;
53998 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53999 wxSize result;
54000 void *argp1 = 0 ;
54001 int res1 = 0 ;
54002 PyObject *swig_obj[1] ;
54003
54004 if (!args) SWIG_fail;
54005 swig_obj[0] = args;
54006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54007 if (!SWIG_IsOK(res1)) {
54008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
54009 }
54010 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54011 {
54012 PyThreadState* __tstate = wxPyBeginAllowThreads();
54013 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
54014 wxPyEndAllowThreads(__tstate);
54015 if (PyErr_Occurred()) SWIG_fail;
54016 }
54017 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54018 return resultobj;
54019 fail:
54020 return NULL;
54021 }
54022
54023
54024 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54025 PyObject *resultobj = 0;
54026 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54027 wxSize *arg2 = 0 ;
54028 void *argp1 = 0 ;
54029 int res1 = 0 ;
54030 wxSize temp2 ;
54031 PyObject * obj0 = 0 ;
54032 PyObject * obj1 = 0 ;
54033 char * kwnames[] = {
54034 (char *) "self",(char *) "sz", NULL
54035 };
54036
54037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
54038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54039 if (!SWIG_IsOK(res1)) {
54040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54041 }
54042 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54043 {
54044 arg2 = &temp2;
54045 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
54046 }
54047 {
54048 PyThreadState* __tstate = wxPyBeginAllowThreads();
54049 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
54050 wxPyEndAllowThreads(__tstate);
54051 if (PyErr_Occurred()) SWIG_fail;
54052 }
54053 resultobj = SWIG_Py_Void();
54054 return resultobj;
54055 fail:
54056 return NULL;
54057 }
54058
54059
54060 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54061 PyObject *resultobj = 0;
54062 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54063 wxWindow *arg2 = (wxWindow *) 0 ;
54064 wxGBPosition result;
54065 void *argp1 = 0 ;
54066 int res1 = 0 ;
54067 void *argp2 = 0 ;
54068 int res2 = 0 ;
54069
54070 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54072 if (!SWIG_IsOK(res1)) {
54073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54074 }
54075 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54076 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54077 if (!SWIG_IsOK(res2)) {
54078 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54079 }
54080 arg2 = reinterpret_cast< wxWindow * >(argp2);
54081 {
54082 PyThreadState* __tstate = wxPyBeginAllowThreads();
54083 result = (arg1)->GetItemPosition(arg2);
54084 wxPyEndAllowThreads(__tstate);
54085 if (PyErr_Occurred()) SWIG_fail;
54086 }
54087 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54088 return resultobj;
54089 fail:
54090 return NULL;
54091 }
54092
54093
54094 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54095 PyObject *resultobj = 0;
54096 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54097 wxSizer *arg2 = (wxSizer *) 0 ;
54098 wxGBPosition result;
54099 void *argp1 = 0 ;
54100 int res1 = 0 ;
54101 void *argp2 = 0 ;
54102 int res2 = 0 ;
54103
54104 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54106 if (!SWIG_IsOK(res1)) {
54107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54108 }
54109 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54110 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54111 if (!SWIG_IsOK(res2)) {
54112 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54113 }
54114 arg2 = reinterpret_cast< wxSizer * >(argp2);
54115 {
54116 PyThreadState* __tstate = wxPyBeginAllowThreads();
54117 result = (arg1)->GetItemPosition(arg2);
54118 wxPyEndAllowThreads(__tstate);
54119 if (PyErr_Occurred()) SWIG_fail;
54120 }
54121 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54122 return resultobj;
54123 fail:
54124 return NULL;
54125 }
54126
54127
54128 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54129 PyObject *resultobj = 0;
54130 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54131 size_t arg2 ;
54132 wxGBPosition result;
54133 void *argp1 = 0 ;
54134 int res1 = 0 ;
54135 size_t val2 ;
54136 int ecode2 = 0 ;
54137
54138 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54140 if (!SWIG_IsOK(res1)) {
54141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54142 }
54143 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54144 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54145 if (!SWIG_IsOK(ecode2)) {
54146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54147 }
54148 arg2 = static_cast< size_t >(val2);
54149 {
54150 PyThreadState* __tstate = wxPyBeginAllowThreads();
54151 result = (arg1)->GetItemPosition(arg2);
54152 wxPyEndAllowThreads(__tstate);
54153 if (PyErr_Occurred()) SWIG_fail;
54154 }
54155 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54156 return resultobj;
54157 fail:
54158 return NULL;
54159 }
54160
54161
54162 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
54163 int argc;
54164 PyObject *argv[3];
54165
54166 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
54167 --argc;
54168 if (argc == 2) {
54169 int _v = 0;
54170 {
54171 void *vptr = 0;
54172 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54173 _v = SWIG_CheckState(res);
54174 }
54175 if (!_v) goto check_1;
54176 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
54177 }
54178 check_1:
54179
54180 if (argc == 2) {
54181 int _v = 0;
54182 {
54183 void *vptr = 0;
54184 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54185 _v = SWIG_CheckState(res);
54186 }
54187 if (!_v) goto check_2;
54188 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
54189 }
54190 check_2:
54191
54192 if (argc == 2) {
54193 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
54194 }
54195
54196 fail:
54197 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
54198 return NULL;
54199 }
54200
54201
54202 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54203 PyObject *resultobj = 0;
54204 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54205 wxWindow *arg2 = (wxWindow *) 0 ;
54206 wxGBPosition *arg3 = 0 ;
54207 bool result;
54208 void *argp1 = 0 ;
54209 int res1 = 0 ;
54210 void *argp2 = 0 ;
54211 int res2 = 0 ;
54212 wxGBPosition temp3 ;
54213
54214 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54216 if (!SWIG_IsOK(res1)) {
54217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54218 }
54219 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54220 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54221 if (!SWIG_IsOK(res2)) {
54222 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54223 }
54224 arg2 = reinterpret_cast< wxWindow * >(argp2);
54225 {
54226 arg3 = &temp3;
54227 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54228 }
54229 {
54230 PyThreadState* __tstate = wxPyBeginAllowThreads();
54231 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54232 wxPyEndAllowThreads(__tstate);
54233 if (PyErr_Occurred()) SWIG_fail;
54234 }
54235 {
54236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54237 }
54238 return resultobj;
54239 fail:
54240 return NULL;
54241 }
54242
54243
54244 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54245 PyObject *resultobj = 0;
54246 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54247 wxSizer *arg2 = (wxSizer *) 0 ;
54248 wxGBPosition *arg3 = 0 ;
54249 bool result;
54250 void *argp1 = 0 ;
54251 int res1 = 0 ;
54252 void *argp2 = 0 ;
54253 int res2 = 0 ;
54254 wxGBPosition temp3 ;
54255
54256 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54258 if (!SWIG_IsOK(res1)) {
54259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54260 }
54261 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54262 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54263 if (!SWIG_IsOK(res2)) {
54264 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54265 }
54266 arg2 = reinterpret_cast< wxSizer * >(argp2);
54267 {
54268 arg3 = &temp3;
54269 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54270 }
54271 {
54272 PyThreadState* __tstate = wxPyBeginAllowThreads();
54273 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54274 wxPyEndAllowThreads(__tstate);
54275 if (PyErr_Occurred()) SWIG_fail;
54276 }
54277 {
54278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54279 }
54280 return resultobj;
54281 fail:
54282 return NULL;
54283 }
54284
54285
54286 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54287 PyObject *resultobj = 0;
54288 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54289 size_t arg2 ;
54290 wxGBPosition *arg3 = 0 ;
54291 bool result;
54292 void *argp1 = 0 ;
54293 int res1 = 0 ;
54294 size_t val2 ;
54295 int ecode2 = 0 ;
54296 wxGBPosition temp3 ;
54297
54298 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54300 if (!SWIG_IsOK(res1)) {
54301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54302 }
54303 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54304 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54305 if (!SWIG_IsOK(ecode2)) {
54306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54307 }
54308 arg2 = static_cast< size_t >(val2);
54309 {
54310 arg3 = &temp3;
54311 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54312 }
54313 {
54314 PyThreadState* __tstate = wxPyBeginAllowThreads();
54315 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54316 wxPyEndAllowThreads(__tstate);
54317 if (PyErr_Occurred()) SWIG_fail;
54318 }
54319 {
54320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54321 }
54322 return resultobj;
54323 fail:
54324 return NULL;
54325 }
54326
54327
54328 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
54329 int argc;
54330 PyObject *argv[4];
54331
54332 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
54333 --argc;
54334 if (argc == 3) {
54335 int _v = 0;
54336 {
54337 void *vptr = 0;
54338 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54339 _v = SWIG_CheckState(res);
54340 }
54341 if (!_v) goto check_1;
54342 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
54343 }
54344 check_1:
54345
54346 if (argc == 3) {
54347 int _v = 0;
54348 {
54349 void *vptr = 0;
54350 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54351 _v = SWIG_CheckState(res);
54352 }
54353 if (!_v) goto check_2;
54354 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
54355 }
54356 check_2:
54357
54358 if (argc == 3) {
54359 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
54360 }
54361
54362 fail:
54363 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
54364 return NULL;
54365 }
54366
54367
54368 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54369 PyObject *resultobj = 0;
54370 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54371 wxWindow *arg2 = (wxWindow *) 0 ;
54372 wxGBSpan result;
54373 void *argp1 = 0 ;
54374 int res1 = 0 ;
54375 void *argp2 = 0 ;
54376 int res2 = 0 ;
54377
54378 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54380 if (!SWIG_IsOK(res1)) {
54381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54382 }
54383 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54384 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54385 if (!SWIG_IsOK(res2)) {
54386 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54387 }
54388 arg2 = reinterpret_cast< wxWindow * >(argp2);
54389 {
54390 PyThreadState* __tstate = wxPyBeginAllowThreads();
54391 result = (arg1)->GetItemSpan(arg2);
54392 wxPyEndAllowThreads(__tstate);
54393 if (PyErr_Occurred()) SWIG_fail;
54394 }
54395 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54396 return resultobj;
54397 fail:
54398 return NULL;
54399 }
54400
54401
54402 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54403 PyObject *resultobj = 0;
54404 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54405 wxSizer *arg2 = (wxSizer *) 0 ;
54406 wxGBSpan result;
54407 void *argp1 = 0 ;
54408 int res1 = 0 ;
54409 void *argp2 = 0 ;
54410 int res2 = 0 ;
54411
54412 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54414 if (!SWIG_IsOK(res1)) {
54415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54416 }
54417 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54418 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54419 if (!SWIG_IsOK(res2)) {
54420 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54421 }
54422 arg2 = reinterpret_cast< wxSizer * >(argp2);
54423 {
54424 PyThreadState* __tstate = wxPyBeginAllowThreads();
54425 result = (arg1)->GetItemSpan(arg2);
54426 wxPyEndAllowThreads(__tstate);
54427 if (PyErr_Occurred()) SWIG_fail;
54428 }
54429 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54430 return resultobj;
54431 fail:
54432 return NULL;
54433 }
54434
54435
54436 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54437 PyObject *resultobj = 0;
54438 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54439 size_t arg2 ;
54440 wxGBSpan result;
54441 void *argp1 = 0 ;
54442 int res1 = 0 ;
54443 size_t val2 ;
54444 int ecode2 = 0 ;
54445
54446 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54448 if (!SWIG_IsOK(res1)) {
54449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54450 }
54451 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54452 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54453 if (!SWIG_IsOK(ecode2)) {
54454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54455 }
54456 arg2 = static_cast< size_t >(val2);
54457 {
54458 PyThreadState* __tstate = wxPyBeginAllowThreads();
54459 result = (arg1)->GetItemSpan(arg2);
54460 wxPyEndAllowThreads(__tstate);
54461 if (PyErr_Occurred()) SWIG_fail;
54462 }
54463 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54464 return resultobj;
54465 fail:
54466 return NULL;
54467 }
54468
54469
54470 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
54471 int argc;
54472 PyObject *argv[3];
54473
54474 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
54475 --argc;
54476 if (argc == 2) {
54477 int _v = 0;
54478 {
54479 void *vptr = 0;
54480 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54481 _v = SWIG_CheckState(res);
54482 }
54483 if (!_v) goto check_1;
54484 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
54485 }
54486 check_1:
54487
54488 if (argc == 2) {
54489 int _v = 0;
54490 {
54491 void *vptr = 0;
54492 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54493 _v = SWIG_CheckState(res);
54494 }
54495 if (!_v) goto check_2;
54496 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
54497 }
54498 check_2:
54499
54500 if (argc == 2) {
54501 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
54502 }
54503
54504 fail:
54505 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
54506 return NULL;
54507 }
54508
54509
54510 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54511 PyObject *resultobj = 0;
54512 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54513 wxWindow *arg2 = (wxWindow *) 0 ;
54514 wxGBSpan *arg3 = 0 ;
54515 bool result;
54516 void *argp1 = 0 ;
54517 int res1 = 0 ;
54518 void *argp2 = 0 ;
54519 int res2 = 0 ;
54520 wxGBSpan temp3 ;
54521
54522 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54524 if (!SWIG_IsOK(res1)) {
54525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54526 }
54527 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54528 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54529 if (!SWIG_IsOK(res2)) {
54530 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54531 }
54532 arg2 = reinterpret_cast< wxWindow * >(argp2);
54533 {
54534 arg3 = &temp3;
54535 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54536 }
54537 {
54538 PyThreadState* __tstate = wxPyBeginAllowThreads();
54539 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54540 wxPyEndAllowThreads(__tstate);
54541 if (PyErr_Occurred()) SWIG_fail;
54542 }
54543 {
54544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54545 }
54546 return resultobj;
54547 fail:
54548 return NULL;
54549 }
54550
54551
54552 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54553 PyObject *resultobj = 0;
54554 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54555 wxSizer *arg2 = (wxSizer *) 0 ;
54556 wxGBSpan *arg3 = 0 ;
54557 bool result;
54558 void *argp1 = 0 ;
54559 int res1 = 0 ;
54560 void *argp2 = 0 ;
54561 int res2 = 0 ;
54562 wxGBSpan temp3 ;
54563
54564 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54566 if (!SWIG_IsOK(res1)) {
54567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54568 }
54569 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54570 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54571 if (!SWIG_IsOK(res2)) {
54572 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54573 }
54574 arg2 = reinterpret_cast< wxSizer * >(argp2);
54575 {
54576 arg3 = &temp3;
54577 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54578 }
54579 {
54580 PyThreadState* __tstate = wxPyBeginAllowThreads();
54581 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54582 wxPyEndAllowThreads(__tstate);
54583 if (PyErr_Occurred()) SWIG_fail;
54584 }
54585 {
54586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54587 }
54588 return resultobj;
54589 fail:
54590 return NULL;
54591 }
54592
54593
54594 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54595 PyObject *resultobj = 0;
54596 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54597 size_t arg2 ;
54598 wxGBSpan *arg3 = 0 ;
54599 bool result;
54600 void *argp1 = 0 ;
54601 int res1 = 0 ;
54602 size_t val2 ;
54603 int ecode2 = 0 ;
54604 wxGBSpan temp3 ;
54605
54606 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54608 if (!SWIG_IsOK(res1)) {
54609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54610 }
54611 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54612 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54613 if (!SWIG_IsOK(ecode2)) {
54614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54615 }
54616 arg2 = static_cast< size_t >(val2);
54617 {
54618 arg3 = &temp3;
54619 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54620 }
54621 {
54622 PyThreadState* __tstate = wxPyBeginAllowThreads();
54623 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54624 wxPyEndAllowThreads(__tstate);
54625 if (PyErr_Occurred()) SWIG_fail;
54626 }
54627 {
54628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54629 }
54630 return resultobj;
54631 fail:
54632 return NULL;
54633 }
54634
54635
54636 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
54637 int argc;
54638 PyObject *argv[4];
54639
54640 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
54641 --argc;
54642 if (argc == 3) {
54643 int _v = 0;
54644 {
54645 void *vptr = 0;
54646 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54647 _v = SWIG_CheckState(res);
54648 }
54649 if (!_v) goto check_1;
54650 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
54651 }
54652 check_1:
54653
54654 if (argc == 3) {
54655 int _v = 0;
54656 {
54657 void *vptr = 0;
54658 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54659 _v = SWIG_CheckState(res);
54660 }
54661 if (!_v) goto check_2;
54662 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
54663 }
54664 check_2:
54665
54666 if (argc == 3) {
54667 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
54668 }
54669
54670 fail:
54671 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
54672 return NULL;
54673 }
54674
54675
54676 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54677 PyObject *resultobj = 0;
54678 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54679 wxWindow *arg2 = (wxWindow *) 0 ;
54680 wxGBSizerItem *result = 0 ;
54681 void *argp1 = 0 ;
54682 int res1 = 0 ;
54683 void *argp2 = 0 ;
54684 int res2 = 0 ;
54685
54686 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54688 if (!SWIG_IsOK(res1)) {
54689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54690 }
54691 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54692 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54693 if (!SWIG_IsOK(res2)) {
54694 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
54695 }
54696 arg2 = reinterpret_cast< wxWindow * >(argp2);
54697 {
54698 PyThreadState* __tstate = wxPyBeginAllowThreads();
54699 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54700 wxPyEndAllowThreads(__tstate);
54701 if (PyErr_Occurred()) SWIG_fail;
54702 }
54703 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54704 return resultobj;
54705 fail:
54706 return NULL;
54707 }
54708
54709
54710 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54711 PyObject *resultobj = 0;
54712 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54713 wxSizer *arg2 = (wxSizer *) 0 ;
54714 wxGBSizerItem *result = 0 ;
54715 void *argp1 = 0 ;
54716 int res1 = 0 ;
54717 void *argp2 = 0 ;
54718 int res2 = 0 ;
54719
54720 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54722 if (!SWIG_IsOK(res1)) {
54723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54724 }
54725 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54726 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54727 if (!SWIG_IsOK(res2)) {
54728 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
54729 }
54730 arg2 = reinterpret_cast< wxSizer * >(argp2);
54731 {
54732 PyThreadState* __tstate = wxPyBeginAllowThreads();
54733 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54734 wxPyEndAllowThreads(__tstate);
54735 if (PyErr_Occurred()) SWIG_fail;
54736 }
54737 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54738 return resultobj;
54739 fail:
54740 return NULL;
54741 }
54742
54743
54744 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
54745 int argc;
54746 PyObject *argv[3];
54747
54748 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
54749 --argc;
54750 if (argc == 2) {
54751 int _v = 0;
54752 {
54753 void *vptr = 0;
54754 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54755 _v = SWIG_CheckState(res);
54756 }
54757 if (!_v) goto check_1;
54758 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
54759 }
54760 check_1:
54761
54762 if (argc == 2) {
54763 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
54764 }
54765
54766 fail:
54767 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
54768 return NULL;
54769 }
54770
54771
54772 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54773 PyObject *resultobj = 0;
54774 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54775 wxGBPosition *arg2 = 0 ;
54776 wxGBSizerItem *result = 0 ;
54777 void *argp1 = 0 ;
54778 int res1 = 0 ;
54779 wxGBPosition temp2 ;
54780 PyObject * obj0 = 0 ;
54781 PyObject * obj1 = 0 ;
54782 char * kwnames[] = {
54783 (char *) "self",(char *) "pos", NULL
54784 };
54785
54786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
54787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54788 if (!SWIG_IsOK(res1)) {
54789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54790 }
54791 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54792 {
54793 arg2 = &temp2;
54794 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54795 }
54796 {
54797 PyThreadState* __tstate = wxPyBeginAllowThreads();
54798 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
54799 wxPyEndAllowThreads(__tstate);
54800 if (PyErr_Occurred()) SWIG_fail;
54801 }
54802 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54803 return resultobj;
54804 fail:
54805 return NULL;
54806 }
54807
54808
54809 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54810 PyObject *resultobj = 0;
54811 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54812 wxPoint *arg2 = 0 ;
54813 wxGBSizerItem *result = 0 ;
54814 void *argp1 = 0 ;
54815 int res1 = 0 ;
54816 wxPoint temp2 ;
54817 PyObject * obj0 = 0 ;
54818 PyObject * obj1 = 0 ;
54819 char * kwnames[] = {
54820 (char *) "self",(char *) "pt", NULL
54821 };
54822
54823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
54824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54825 if (!SWIG_IsOK(res1)) {
54826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54827 }
54828 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54829 {
54830 arg2 = &temp2;
54831 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
54832 }
54833 {
54834 PyThreadState* __tstate = wxPyBeginAllowThreads();
54835 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
54836 wxPyEndAllowThreads(__tstate);
54837 if (PyErr_Occurred()) SWIG_fail;
54838 }
54839 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54840 return resultobj;
54841 fail:
54842 return NULL;
54843 }
54844
54845
54846 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54847 PyObject *resultobj = 0;
54848 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54849 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
54850 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
54851 bool result;
54852 void *argp1 = 0 ;
54853 int res1 = 0 ;
54854 void *argp2 = 0 ;
54855 int res2 = 0 ;
54856 void *argp3 = 0 ;
54857 int res3 = 0 ;
54858 PyObject * obj0 = 0 ;
54859 PyObject * obj1 = 0 ;
54860 PyObject * obj2 = 0 ;
54861 char * kwnames[] = {
54862 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
54863 };
54864
54865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54867 if (!SWIG_IsOK(res1)) {
54868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54869 }
54870 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54871 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54872 if (!SWIG_IsOK(res2)) {
54873 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
54874 }
54875 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
54876 if (obj2) {
54877 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54878 if (!SWIG_IsOK(res3)) {
54879 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
54880 }
54881 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
54882 }
54883 {
54884 PyThreadState* __tstate = wxPyBeginAllowThreads();
54885 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
54886 wxPyEndAllowThreads(__tstate);
54887 if (PyErr_Occurred()) SWIG_fail;
54888 }
54889 {
54890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54891 }
54892 return resultobj;
54893 fail:
54894 return NULL;
54895 }
54896
54897
54898 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54899 PyObject *resultobj = 0;
54900 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54901 wxGBPosition *arg2 = 0 ;
54902 wxGBSpan *arg3 = 0 ;
54903 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
54904 bool result;
54905 void *argp1 = 0 ;
54906 int res1 = 0 ;
54907 wxGBPosition temp2 ;
54908 wxGBSpan temp3 ;
54909 void *argp4 = 0 ;
54910 int res4 = 0 ;
54911 PyObject * obj0 = 0 ;
54912 PyObject * obj1 = 0 ;
54913 PyObject * obj2 = 0 ;
54914 PyObject * obj3 = 0 ;
54915 char * kwnames[] = {
54916 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
54917 };
54918
54919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
54920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54921 if (!SWIG_IsOK(res1)) {
54922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54923 }
54924 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54925 {
54926 arg2 = &temp2;
54927 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54928 }
54929 {
54930 arg3 = &temp3;
54931 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
54932 }
54933 if (obj3) {
54934 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54935 if (!SWIG_IsOK(res4)) {
54936 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
54937 }
54938 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
54939 }
54940 {
54941 PyThreadState* __tstate = wxPyBeginAllowThreads();
54942 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
54943 wxPyEndAllowThreads(__tstate);
54944 if (PyErr_Occurred()) SWIG_fail;
54945 }
54946 {
54947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54948 }
54949 return resultobj;
54950 fail:
54951 return NULL;
54952 }
54953
54954
54955 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54956 PyObject *obj;
54957 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54958 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
54959 return SWIG_Py_Void();
54960 }
54961
54962 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54963 return SWIG_Python_InitShadowInstance(args);
54964 }
54965
54966 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54967 PyObject *resultobj = 0;
54968 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
54969 wxRelationship arg2 ;
54970 wxWindow *arg3 = (wxWindow *) 0 ;
54971 wxEdge arg4 ;
54972 int arg5 = (int) 0 ;
54973 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
54974 void *argp1 = 0 ;
54975 int res1 = 0 ;
54976 int val2 ;
54977 int ecode2 = 0 ;
54978 void *argp3 = 0 ;
54979 int res3 = 0 ;
54980 int val4 ;
54981 int ecode4 = 0 ;
54982 int val5 ;
54983 int ecode5 = 0 ;
54984 int val6 ;
54985 int ecode6 = 0 ;
54986 PyObject * obj0 = 0 ;
54987 PyObject * obj1 = 0 ;
54988 PyObject * obj2 = 0 ;
54989 PyObject * obj3 = 0 ;
54990 PyObject * obj4 = 0 ;
54991 PyObject * obj5 = 0 ;
54992 char * kwnames[] = {
54993 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
54994 };
54995
54996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
54997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54998 if (!SWIG_IsOK(res1)) {
54999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55000 }
55001 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55002 ecode2 = SWIG_AsVal_int(obj1, &val2);
55003 if (!SWIG_IsOK(ecode2)) {
55004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
55005 }
55006 arg2 = static_cast< wxRelationship >(val2);
55007 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
55008 if (!SWIG_IsOK(res3)) {
55009 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
55010 }
55011 arg3 = reinterpret_cast< wxWindow * >(argp3);
55012 ecode4 = SWIG_AsVal_int(obj3, &val4);
55013 if (!SWIG_IsOK(ecode4)) {
55014 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
55015 }
55016 arg4 = static_cast< wxEdge >(val4);
55017 if (obj4) {
55018 ecode5 = SWIG_AsVal_int(obj4, &val5);
55019 if (!SWIG_IsOK(ecode5)) {
55020 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
55021 }
55022 arg5 = static_cast< int >(val5);
55023 }
55024 if (obj5) {
55025 ecode6 = SWIG_AsVal_int(obj5, &val6);
55026 if (!SWIG_IsOK(ecode6)) {
55027 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
55028 }
55029 arg6 = static_cast< int >(val6);
55030 }
55031 {
55032 PyThreadState* __tstate = wxPyBeginAllowThreads();
55033 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
55034 wxPyEndAllowThreads(__tstate);
55035 if (PyErr_Occurred()) SWIG_fail;
55036 }
55037 resultobj = SWIG_Py_Void();
55038 return resultobj;
55039 fail:
55040 return NULL;
55041 }
55042
55043
55044 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55045 PyObject *resultobj = 0;
55046 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55047 wxWindow *arg2 = (wxWindow *) 0 ;
55048 int arg3 = (int) 0 ;
55049 void *argp1 = 0 ;
55050 int res1 = 0 ;
55051 void *argp2 = 0 ;
55052 int res2 = 0 ;
55053 int val3 ;
55054 int ecode3 = 0 ;
55055 PyObject * obj0 = 0 ;
55056 PyObject * obj1 = 0 ;
55057 PyObject * obj2 = 0 ;
55058 char * kwnames[] = {
55059 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55060 };
55061
55062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55064 if (!SWIG_IsOK(res1)) {
55065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55066 }
55067 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55068 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55069 if (!SWIG_IsOK(res2)) {
55070 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55071 }
55072 arg2 = reinterpret_cast< wxWindow * >(argp2);
55073 if (obj2) {
55074 ecode3 = SWIG_AsVal_int(obj2, &val3);
55075 if (!SWIG_IsOK(ecode3)) {
55076 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
55077 }
55078 arg3 = static_cast< int >(val3);
55079 }
55080 {
55081 PyThreadState* __tstate = wxPyBeginAllowThreads();
55082 (arg1)->LeftOf(arg2,arg3);
55083 wxPyEndAllowThreads(__tstate);
55084 if (PyErr_Occurred()) SWIG_fail;
55085 }
55086 resultobj = SWIG_Py_Void();
55087 return resultobj;
55088 fail:
55089 return NULL;
55090 }
55091
55092
55093 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55094 PyObject *resultobj = 0;
55095 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55096 wxWindow *arg2 = (wxWindow *) 0 ;
55097 int arg3 = (int) 0 ;
55098 void *argp1 = 0 ;
55099 int res1 = 0 ;
55100 void *argp2 = 0 ;
55101 int res2 = 0 ;
55102 int val3 ;
55103 int ecode3 = 0 ;
55104 PyObject * obj0 = 0 ;
55105 PyObject * obj1 = 0 ;
55106 PyObject * obj2 = 0 ;
55107 char * kwnames[] = {
55108 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55109 };
55110
55111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55113 if (!SWIG_IsOK(res1)) {
55114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55115 }
55116 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55117 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55118 if (!SWIG_IsOK(res2)) {
55119 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55120 }
55121 arg2 = reinterpret_cast< wxWindow * >(argp2);
55122 if (obj2) {
55123 ecode3 = SWIG_AsVal_int(obj2, &val3);
55124 if (!SWIG_IsOK(ecode3)) {
55125 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
55126 }
55127 arg3 = static_cast< int >(val3);
55128 }
55129 {
55130 PyThreadState* __tstate = wxPyBeginAllowThreads();
55131 (arg1)->RightOf(arg2,arg3);
55132 wxPyEndAllowThreads(__tstate);
55133 if (PyErr_Occurred()) SWIG_fail;
55134 }
55135 resultobj = SWIG_Py_Void();
55136 return resultobj;
55137 fail:
55138 return NULL;
55139 }
55140
55141
55142 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55143 PyObject *resultobj = 0;
55144 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55145 wxWindow *arg2 = (wxWindow *) 0 ;
55146 int arg3 = (int) 0 ;
55147 void *argp1 = 0 ;
55148 int res1 = 0 ;
55149 void *argp2 = 0 ;
55150 int res2 = 0 ;
55151 int val3 ;
55152 int ecode3 = 0 ;
55153 PyObject * obj0 = 0 ;
55154 PyObject * obj1 = 0 ;
55155 PyObject * obj2 = 0 ;
55156 char * kwnames[] = {
55157 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55158 };
55159
55160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55162 if (!SWIG_IsOK(res1)) {
55163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55164 }
55165 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55166 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55167 if (!SWIG_IsOK(res2)) {
55168 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
55169 }
55170 arg2 = reinterpret_cast< wxWindow * >(argp2);
55171 if (obj2) {
55172 ecode3 = SWIG_AsVal_int(obj2, &val3);
55173 if (!SWIG_IsOK(ecode3)) {
55174 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
55175 }
55176 arg3 = static_cast< int >(val3);
55177 }
55178 {
55179 PyThreadState* __tstate = wxPyBeginAllowThreads();
55180 (arg1)->Above(arg2,arg3);
55181 wxPyEndAllowThreads(__tstate);
55182 if (PyErr_Occurred()) SWIG_fail;
55183 }
55184 resultobj = SWIG_Py_Void();
55185 return resultobj;
55186 fail:
55187 return NULL;
55188 }
55189
55190
55191 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55192 PyObject *resultobj = 0;
55193 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55194 wxWindow *arg2 = (wxWindow *) 0 ;
55195 int arg3 = (int) 0 ;
55196 void *argp1 = 0 ;
55197 int res1 = 0 ;
55198 void *argp2 = 0 ;
55199 int res2 = 0 ;
55200 int val3 ;
55201 int ecode3 = 0 ;
55202 PyObject * obj0 = 0 ;
55203 PyObject * obj1 = 0 ;
55204 PyObject * obj2 = 0 ;
55205 char * kwnames[] = {
55206 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55207 };
55208
55209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55211 if (!SWIG_IsOK(res1)) {
55212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55213 }
55214 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55215 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55216 if (!SWIG_IsOK(res2)) {
55217 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
55218 }
55219 arg2 = reinterpret_cast< wxWindow * >(argp2);
55220 if (obj2) {
55221 ecode3 = SWIG_AsVal_int(obj2, &val3);
55222 if (!SWIG_IsOK(ecode3)) {
55223 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
55224 }
55225 arg3 = static_cast< int >(val3);
55226 }
55227 {
55228 PyThreadState* __tstate = wxPyBeginAllowThreads();
55229 (arg1)->Below(arg2,arg3);
55230 wxPyEndAllowThreads(__tstate);
55231 if (PyErr_Occurred()) SWIG_fail;
55232 }
55233 resultobj = SWIG_Py_Void();
55234 return resultobj;
55235 fail:
55236 return NULL;
55237 }
55238
55239
55240 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55241 PyObject *resultobj = 0;
55242 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55243 wxWindow *arg2 = (wxWindow *) 0 ;
55244 wxEdge arg3 ;
55245 int arg4 = (int) 0 ;
55246 void *argp1 = 0 ;
55247 int res1 = 0 ;
55248 void *argp2 = 0 ;
55249 int res2 = 0 ;
55250 int val3 ;
55251 int ecode3 = 0 ;
55252 int val4 ;
55253 int ecode4 = 0 ;
55254 PyObject * obj0 = 0 ;
55255 PyObject * obj1 = 0 ;
55256 PyObject * obj2 = 0 ;
55257 PyObject * obj3 = 0 ;
55258 char * kwnames[] = {
55259 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
55260 };
55261
55262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55264 if (!SWIG_IsOK(res1)) {
55265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55266 }
55267 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55268 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55269 if (!SWIG_IsOK(res2)) {
55270 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
55271 }
55272 arg2 = reinterpret_cast< wxWindow * >(argp2);
55273 ecode3 = SWIG_AsVal_int(obj2, &val3);
55274 if (!SWIG_IsOK(ecode3)) {
55275 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
55276 }
55277 arg3 = static_cast< wxEdge >(val3);
55278 if (obj3) {
55279 ecode4 = SWIG_AsVal_int(obj3, &val4);
55280 if (!SWIG_IsOK(ecode4)) {
55281 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
55282 }
55283 arg4 = static_cast< int >(val4);
55284 }
55285 {
55286 PyThreadState* __tstate = wxPyBeginAllowThreads();
55287 (arg1)->SameAs(arg2,arg3,arg4);
55288 wxPyEndAllowThreads(__tstate);
55289 if (PyErr_Occurred()) SWIG_fail;
55290 }
55291 resultobj = SWIG_Py_Void();
55292 return resultobj;
55293 fail:
55294 return NULL;
55295 }
55296
55297
55298 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55299 PyObject *resultobj = 0;
55300 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55301 wxWindow *arg2 = (wxWindow *) 0 ;
55302 wxEdge arg3 ;
55303 int arg4 ;
55304 void *argp1 = 0 ;
55305 int res1 = 0 ;
55306 void *argp2 = 0 ;
55307 int res2 = 0 ;
55308 int val3 ;
55309 int ecode3 = 0 ;
55310 int val4 ;
55311 int ecode4 = 0 ;
55312 PyObject * obj0 = 0 ;
55313 PyObject * obj1 = 0 ;
55314 PyObject * obj2 = 0 ;
55315 PyObject * obj3 = 0 ;
55316 char * kwnames[] = {
55317 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
55318 };
55319
55320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55322 if (!SWIG_IsOK(res1)) {
55323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55324 }
55325 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55326 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55327 if (!SWIG_IsOK(res2)) {
55328 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55329 }
55330 arg2 = reinterpret_cast< wxWindow * >(argp2);
55331 ecode3 = SWIG_AsVal_int(obj2, &val3);
55332 if (!SWIG_IsOK(ecode3)) {
55333 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
55334 }
55335 arg3 = static_cast< wxEdge >(val3);
55336 ecode4 = SWIG_AsVal_int(obj3, &val4);
55337 if (!SWIG_IsOK(ecode4)) {
55338 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
55339 }
55340 arg4 = static_cast< int >(val4);
55341 {
55342 PyThreadState* __tstate = wxPyBeginAllowThreads();
55343 (arg1)->PercentOf(arg2,arg3,arg4);
55344 wxPyEndAllowThreads(__tstate);
55345 if (PyErr_Occurred()) SWIG_fail;
55346 }
55347 resultobj = SWIG_Py_Void();
55348 return resultobj;
55349 fail:
55350 return NULL;
55351 }
55352
55353
55354 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55355 PyObject *resultobj = 0;
55356 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55357 int arg2 ;
55358 void *argp1 = 0 ;
55359 int res1 = 0 ;
55360 int val2 ;
55361 int ecode2 = 0 ;
55362 PyObject * obj0 = 0 ;
55363 PyObject * obj1 = 0 ;
55364 char * kwnames[] = {
55365 (char *) "self",(char *) "val", NULL
55366 };
55367
55368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
55369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55370 if (!SWIG_IsOK(res1)) {
55371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55372 }
55373 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55374 ecode2 = SWIG_AsVal_int(obj1, &val2);
55375 if (!SWIG_IsOK(ecode2)) {
55376 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
55377 }
55378 arg2 = static_cast< int >(val2);
55379 {
55380 PyThreadState* __tstate = wxPyBeginAllowThreads();
55381 (arg1)->Absolute(arg2);
55382 wxPyEndAllowThreads(__tstate);
55383 if (PyErr_Occurred()) SWIG_fail;
55384 }
55385 resultobj = SWIG_Py_Void();
55386 return resultobj;
55387 fail:
55388 return NULL;
55389 }
55390
55391
55392 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55393 PyObject *resultobj = 0;
55394 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55395 void *argp1 = 0 ;
55396 int res1 = 0 ;
55397 PyObject *swig_obj[1] ;
55398
55399 if (!args) SWIG_fail;
55400 swig_obj[0] = args;
55401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55402 if (!SWIG_IsOK(res1)) {
55403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55404 }
55405 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55406 {
55407 PyThreadState* __tstate = wxPyBeginAllowThreads();
55408 (arg1)->Unconstrained();
55409 wxPyEndAllowThreads(__tstate);
55410 if (PyErr_Occurred()) SWIG_fail;
55411 }
55412 resultobj = SWIG_Py_Void();
55413 return resultobj;
55414 fail:
55415 return NULL;
55416 }
55417
55418
55419 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55420 PyObject *resultobj = 0;
55421 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55422 void *argp1 = 0 ;
55423 int res1 = 0 ;
55424 PyObject *swig_obj[1] ;
55425
55426 if (!args) SWIG_fail;
55427 swig_obj[0] = args;
55428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55429 if (!SWIG_IsOK(res1)) {
55430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55431 }
55432 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55433 {
55434 PyThreadState* __tstate = wxPyBeginAllowThreads();
55435 (arg1)->AsIs();
55436 wxPyEndAllowThreads(__tstate);
55437 if (PyErr_Occurred()) SWIG_fail;
55438 }
55439 resultobj = SWIG_Py_Void();
55440 return resultobj;
55441 fail:
55442 return NULL;
55443 }
55444
55445
55446 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55447 PyObject *resultobj = 0;
55448 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55449 wxWindow *result = 0 ;
55450 void *argp1 = 0 ;
55451 int res1 = 0 ;
55452 PyObject *swig_obj[1] ;
55453
55454 if (!args) SWIG_fail;
55455 swig_obj[0] = args;
55456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55457 if (!SWIG_IsOK(res1)) {
55458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55459 }
55460 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55461 {
55462 PyThreadState* __tstate = wxPyBeginAllowThreads();
55463 result = (wxWindow *)(arg1)->GetOtherWindow();
55464 wxPyEndAllowThreads(__tstate);
55465 if (PyErr_Occurred()) SWIG_fail;
55466 }
55467 {
55468 resultobj = wxPyMake_wxObject(result, 0);
55469 }
55470 return resultobj;
55471 fail:
55472 return NULL;
55473 }
55474
55475
55476 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55477 PyObject *resultobj = 0;
55478 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55479 wxEdge result;
55480 void *argp1 = 0 ;
55481 int res1 = 0 ;
55482 PyObject *swig_obj[1] ;
55483
55484 if (!args) SWIG_fail;
55485 swig_obj[0] = args;
55486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55487 if (!SWIG_IsOK(res1)) {
55488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55489 }
55490 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55491 {
55492 PyThreadState* __tstate = wxPyBeginAllowThreads();
55493 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
55494 wxPyEndAllowThreads(__tstate);
55495 if (PyErr_Occurred()) SWIG_fail;
55496 }
55497 resultobj = SWIG_From_int(static_cast< int >(result));
55498 return resultobj;
55499 fail:
55500 return NULL;
55501 }
55502
55503
55504 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55505 PyObject *resultobj = 0;
55506 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55507 wxEdge arg2 ;
55508 void *argp1 = 0 ;
55509 int res1 = 0 ;
55510 int val2 ;
55511 int ecode2 = 0 ;
55512 PyObject * obj0 = 0 ;
55513 PyObject * obj1 = 0 ;
55514 char * kwnames[] = {
55515 (char *) "self",(char *) "which", NULL
55516 };
55517
55518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
55519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55520 if (!SWIG_IsOK(res1)) {
55521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55522 }
55523 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55524 ecode2 = SWIG_AsVal_int(obj1, &val2);
55525 if (!SWIG_IsOK(ecode2)) {
55526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
55527 }
55528 arg2 = static_cast< wxEdge >(val2);
55529 {
55530 PyThreadState* __tstate = wxPyBeginAllowThreads();
55531 (arg1)->SetEdge(arg2);
55532 wxPyEndAllowThreads(__tstate);
55533 if (PyErr_Occurred()) SWIG_fail;
55534 }
55535 resultobj = SWIG_Py_Void();
55536 return resultobj;
55537 fail:
55538 return NULL;
55539 }
55540
55541
55542 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55543 PyObject *resultobj = 0;
55544 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55545 int arg2 ;
55546 void *argp1 = 0 ;
55547 int res1 = 0 ;
55548 int val2 ;
55549 int ecode2 = 0 ;
55550 PyObject * obj0 = 0 ;
55551 PyObject * obj1 = 0 ;
55552 char * kwnames[] = {
55553 (char *) "self",(char *) "v", NULL
55554 };
55555
55556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
55557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55558 if (!SWIG_IsOK(res1)) {
55559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55560 }
55561 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55562 ecode2 = SWIG_AsVal_int(obj1, &val2);
55563 if (!SWIG_IsOK(ecode2)) {
55564 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
55565 }
55566 arg2 = static_cast< int >(val2);
55567 {
55568 PyThreadState* __tstate = wxPyBeginAllowThreads();
55569 (arg1)->SetValue(arg2);
55570 wxPyEndAllowThreads(__tstate);
55571 if (PyErr_Occurred()) SWIG_fail;
55572 }
55573 resultobj = SWIG_Py_Void();
55574 return resultobj;
55575 fail:
55576 return NULL;
55577 }
55578
55579
55580 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55581 PyObject *resultobj = 0;
55582 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55583 int result;
55584 void *argp1 = 0 ;
55585 int res1 = 0 ;
55586 PyObject *swig_obj[1] ;
55587
55588 if (!args) SWIG_fail;
55589 swig_obj[0] = args;
55590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55591 if (!SWIG_IsOK(res1)) {
55592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55593 }
55594 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55595 {
55596 PyThreadState* __tstate = wxPyBeginAllowThreads();
55597 result = (int)(arg1)->GetMargin();
55598 wxPyEndAllowThreads(__tstate);
55599 if (PyErr_Occurred()) SWIG_fail;
55600 }
55601 resultobj = SWIG_From_int(static_cast< int >(result));
55602 return resultobj;
55603 fail:
55604 return NULL;
55605 }
55606
55607
55608 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55609 PyObject *resultobj = 0;
55610 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55611 int arg2 ;
55612 void *argp1 = 0 ;
55613 int res1 = 0 ;
55614 int val2 ;
55615 int ecode2 = 0 ;
55616 PyObject * obj0 = 0 ;
55617 PyObject * obj1 = 0 ;
55618 char * kwnames[] = {
55619 (char *) "self",(char *) "m", NULL
55620 };
55621
55622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
55623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55624 if (!SWIG_IsOK(res1)) {
55625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55626 }
55627 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55628 ecode2 = SWIG_AsVal_int(obj1, &val2);
55629 if (!SWIG_IsOK(ecode2)) {
55630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
55631 }
55632 arg2 = static_cast< int >(val2);
55633 {
55634 PyThreadState* __tstate = wxPyBeginAllowThreads();
55635 (arg1)->SetMargin(arg2);
55636 wxPyEndAllowThreads(__tstate);
55637 if (PyErr_Occurred()) SWIG_fail;
55638 }
55639 resultobj = SWIG_Py_Void();
55640 return resultobj;
55641 fail:
55642 return NULL;
55643 }
55644
55645
55646 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55647 PyObject *resultobj = 0;
55648 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55649 int result;
55650 void *argp1 = 0 ;
55651 int res1 = 0 ;
55652 PyObject *swig_obj[1] ;
55653
55654 if (!args) SWIG_fail;
55655 swig_obj[0] = args;
55656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55657 if (!SWIG_IsOK(res1)) {
55658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55659 }
55660 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55661 {
55662 PyThreadState* __tstate = wxPyBeginAllowThreads();
55663 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
55664 wxPyEndAllowThreads(__tstate);
55665 if (PyErr_Occurred()) SWIG_fail;
55666 }
55667 resultobj = SWIG_From_int(static_cast< int >(result));
55668 return resultobj;
55669 fail:
55670 return NULL;
55671 }
55672
55673
55674 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55675 PyObject *resultobj = 0;
55676 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55677 int result;
55678 void *argp1 = 0 ;
55679 int res1 = 0 ;
55680 PyObject *swig_obj[1] ;
55681
55682 if (!args) SWIG_fail;
55683 swig_obj[0] = args;
55684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55685 if (!SWIG_IsOK(res1)) {
55686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55687 }
55688 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55689 {
55690 PyThreadState* __tstate = wxPyBeginAllowThreads();
55691 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
55692 wxPyEndAllowThreads(__tstate);
55693 if (PyErr_Occurred()) SWIG_fail;
55694 }
55695 resultobj = SWIG_From_int(static_cast< int >(result));
55696 return resultobj;
55697 fail:
55698 return NULL;
55699 }
55700
55701
55702 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55703 PyObject *resultobj = 0;
55704 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55705 int result;
55706 void *argp1 = 0 ;
55707 int res1 = 0 ;
55708 PyObject *swig_obj[1] ;
55709
55710 if (!args) SWIG_fail;
55711 swig_obj[0] = args;
55712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55713 if (!SWIG_IsOK(res1)) {
55714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55715 }
55716 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55717 {
55718 PyThreadState* __tstate = wxPyBeginAllowThreads();
55719 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
55720 wxPyEndAllowThreads(__tstate);
55721 if (PyErr_Occurred()) SWIG_fail;
55722 }
55723 resultobj = SWIG_From_int(static_cast< int >(result));
55724 return resultobj;
55725 fail:
55726 return NULL;
55727 }
55728
55729
55730 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55731 PyObject *resultobj = 0;
55732 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55733 bool result;
55734 void *argp1 = 0 ;
55735 int res1 = 0 ;
55736 PyObject *swig_obj[1] ;
55737
55738 if (!args) SWIG_fail;
55739 swig_obj[0] = args;
55740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55741 if (!SWIG_IsOK(res1)) {
55742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55743 }
55744 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55745 {
55746 PyThreadState* __tstate = wxPyBeginAllowThreads();
55747 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
55748 wxPyEndAllowThreads(__tstate);
55749 if (PyErr_Occurred()) SWIG_fail;
55750 }
55751 {
55752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55753 }
55754 return resultobj;
55755 fail:
55756 return NULL;
55757 }
55758
55759
55760 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55761 PyObject *resultobj = 0;
55762 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55763 bool arg2 ;
55764 void *argp1 = 0 ;
55765 int res1 = 0 ;
55766 bool val2 ;
55767 int ecode2 = 0 ;
55768 PyObject * obj0 = 0 ;
55769 PyObject * obj1 = 0 ;
55770 char * kwnames[] = {
55771 (char *) "self",(char *) "d", NULL
55772 };
55773
55774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
55775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55776 if (!SWIG_IsOK(res1)) {
55777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55778 }
55779 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55780 ecode2 = SWIG_AsVal_bool(obj1, &val2);
55781 if (!SWIG_IsOK(ecode2)) {
55782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
55783 }
55784 arg2 = static_cast< bool >(val2);
55785 {
55786 PyThreadState* __tstate = wxPyBeginAllowThreads();
55787 (arg1)->SetDone(arg2);
55788 wxPyEndAllowThreads(__tstate);
55789 if (PyErr_Occurred()) SWIG_fail;
55790 }
55791 resultobj = SWIG_Py_Void();
55792 return resultobj;
55793 fail:
55794 return NULL;
55795 }
55796
55797
55798 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55799 PyObject *resultobj = 0;
55800 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55801 wxRelationship result;
55802 void *argp1 = 0 ;
55803 int res1 = 0 ;
55804 PyObject *swig_obj[1] ;
55805
55806 if (!args) SWIG_fail;
55807 swig_obj[0] = args;
55808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55809 if (!SWIG_IsOK(res1)) {
55810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55811 }
55812 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55813 {
55814 PyThreadState* __tstate = wxPyBeginAllowThreads();
55815 result = (wxRelationship)(arg1)->GetRelationship();
55816 wxPyEndAllowThreads(__tstate);
55817 if (PyErr_Occurred()) SWIG_fail;
55818 }
55819 resultobj = SWIG_From_int(static_cast< int >(result));
55820 return resultobj;
55821 fail:
55822 return NULL;
55823 }
55824
55825
55826 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55827 PyObject *resultobj = 0;
55828 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55829 wxRelationship arg2 ;
55830 void *argp1 = 0 ;
55831 int res1 = 0 ;
55832 int val2 ;
55833 int ecode2 = 0 ;
55834 PyObject * obj0 = 0 ;
55835 PyObject * obj1 = 0 ;
55836 char * kwnames[] = {
55837 (char *) "self",(char *) "r", NULL
55838 };
55839
55840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
55841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55842 if (!SWIG_IsOK(res1)) {
55843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55844 }
55845 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55846 ecode2 = SWIG_AsVal_int(obj1, &val2);
55847 if (!SWIG_IsOK(ecode2)) {
55848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
55849 }
55850 arg2 = static_cast< wxRelationship >(val2);
55851 {
55852 PyThreadState* __tstate = wxPyBeginAllowThreads();
55853 (arg1)->SetRelationship(arg2);
55854 wxPyEndAllowThreads(__tstate);
55855 if (PyErr_Occurred()) SWIG_fail;
55856 }
55857 resultobj = SWIG_Py_Void();
55858 return resultobj;
55859 fail:
55860 return NULL;
55861 }
55862
55863
55864 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55865 PyObject *resultobj = 0;
55866 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55867 wxWindow *arg2 = (wxWindow *) 0 ;
55868 bool result;
55869 void *argp1 = 0 ;
55870 int res1 = 0 ;
55871 void *argp2 = 0 ;
55872 int res2 = 0 ;
55873 PyObject * obj0 = 0 ;
55874 PyObject * obj1 = 0 ;
55875 char * kwnames[] = {
55876 (char *) "self",(char *) "otherW", NULL
55877 };
55878
55879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
55880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55881 if (!SWIG_IsOK(res1)) {
55882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55883 }
55884 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55885 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55886 if (!SWIG_IsOK(res2)) {
55887 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
55888 }
55889 arg2 = reinterpret_cast< wxWindow * >(argp2);
55890 {
55891 PyThreadState* __tstate = wxPyBeginAllowThreads();
55892 result = (bool)(arg1)->ResetIfWin(arg2);
55893 wxPyEndAllowThreads(__tstate);
55894 if (PyErr_Occurred()) SWIG_fail;
55895 }
55896 {
55897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55898 }
55899 return resultobj;
55900 fail:
55901 return NULL;
55902 }
55903
55904
55905 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55906 PyObject *resultobj = 0;
55907 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55908 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
55909 wxWindow *arg3 = (wxWindow *) 0 ;
55910 bool result;
55911 void *argp1 = 0 ;
55912 int res1 = 0 ;
55913 void *argp2 = 0 ;
55914 int res2 = 0 ;
55915 void *argp3 = 0 ;
55916 int res3 = 0 ;
55917 PyObject * obj0 = 0 ;
55918 PyObject * obj1 = 0 ;
55919 PyObject * obj2 = 0 ;
55920 char * kwnames[] = {
55921 (char *) "self",(char *) "constraints",(char *) "win", NULL
55922 };
55923
55924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55926 if (!SWIG_IsOK(res1)) {
55927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55928 }
55929 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55930 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
55931 if (!SWIG_IsOK(res2)) {
55932 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
55933 }
55934 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
55935 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
55936 if (!SWIG_IsOK(res3)) {
55937 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
55938 }
55939 arg3 = reinterpret_cast< wxWindow * >(argp3);
55940 {
55941 PyThreadState* __tstate = wxPyBeginAllowThreads();
55942 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
55943 wxPyEndAllowThreads(__tstate);
55944 if (PyErr_Occurred()) SWIG_fail;
55945 }
55946 {
55947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55948 }
55949 return resultobj;
55950 fail:
55951 return NULL;
55952 }
55953
55954
55955 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55956 PyObject *resultobj = 0;
55957 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55958 wxEdge arg2 ;
55959 wxWindow *arg3 = (wxWindow *) 0 ;
55960 wxWindow *arg4 = (wxWindow *) 0 ;
55961 int result;
55962 void *argp1 = 0 ;
55963 int res1 = 0 ;
55964 int val2 ;
55965 int ecode2 = 0 ;
55966 void *argp3 = 0 ;
55967 int res3 = 0 ;
55968 void *argp4 = 0 ;
55969 int res4 = 0 ;
55970 PyObject * obj0 = 0 ;
55971 PyObject * obj1 = 0 ;
55972 PyObject * obj2 = 0 ;
55973 PyObject * obj3 = 0 ;
55974 char * kwnames[] = {
55975 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
55976 };
55977
55978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55980 if (!SWIG_IsOK(res1)) {
55981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55982 }
55983 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55984 ecode2 = SWIG_AsVal_int(obj1, &val2);
55985 if (!SWIG_IsOK(ecode2)) {
55986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
55987 }
55988 arg2 = static_cast< wxEdge >(val2);
55989 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
55990 if (!SWIG_IsOK(res3)) {
55991 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
55992 }
55993 arg3 = reinterpret_cast< wxWindow * >(argp3);
55994 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
55995 if (!SWIG_IsOK(res4)) {
55996 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
55997 }
55998 arg4 = reinterpret_cast< wxWindow * >(argp4);
55999 {
56000 PyThreadState* __tstate = wxPyBeginAllowThreads();
56001 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
56002 wxPyEndAllowThreads(__tstate);
56003 if (PyErr_Occurred()) SWIG_fail;
56004 }
56005 resultobj = SWIG_From_int(static_cast< int >(result));
56006 return resultobj;
56007 fail:
56008 return NULL;
56009 }
56010
56011
56012 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56013 PyObject *obj;
56014 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56015 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
56016 return SWIG_Py_Void();
56017 }
56018
56019 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56020 PyObject *resultobj = 0;
56021 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56022 wxIndividualLayoutConstraint *result = 0 ;
56023 void *argp1 = 0 ;
56024 int res1 = 0 ;
56025 PyObject *swig_obj[1] ;
56026
56027 if (!args) SWIG_fail;
56028 swig_obj[0] = args;
56029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56030 if (!SWIG_IsOK(res1)) {
56031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56032 }
56033 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56034 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
56035 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56036 return resultobj;
56037 fail:
56038 return NULL;
56039 }
56040
56041
56042 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56043 PyObject *resultobj = 0;
56044 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56045 wxIndividualLayoutConstraint *result = 0 ;
56046 void *argp1 = 0 ;
56047 int res1 = 0 ;
56048 PyObject *swig_obj[1] ;
56049
56050 if (!args) SWIG_fail;
56051 swig_obj[0] = args;
56052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56053 if (!SWIG_IsOK(res1)) {
56054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56055 }
56056 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56057 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
56058 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56059 return resultobj;
56060 fail:
56061 return NULL;
56062 }
56063
56064
56065 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56066 PyObject *resultobj = 0;
56067 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56068 wxIndividualLayoutConstraint *result = 0 ;
56069 void *argp1 = 0 ;
56070 int res1 = 0 ;
56071 PyObject *swig_obj[1] ;
56072
56073 if (!args) SWIG_fail;
56074 swig_obj[0] = args;
56075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56076 if (!SWIG_IsOK(res1)) {
56077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56078 }
56079 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56080 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
56081 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56082 return resultobj;
56083 fail:
56084 return NULL;
56085 }
56086
56087
56088 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56089 PyObject *resultobj = 0;
56090 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56091 wxIndividualLayoutConstraint *result = 0 ;
56092 void *argp1 = 0 ;
56093 int res1 = 0 ;
56094 PyObject *swig_obj[1] ;
56095
56096 if (!args) SWIG_fail;
56097 swig_obj[0] = args;
56098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56099 if (!SWIG_IsOK(res1)) {
56100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56101 }
56102 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56103 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
56104 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56105 return resultobj;
56106 fail:
56107 return NULL;
56108 }
56109
56110
56111 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56112 PyObject *resultobj = 0;
56113 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56114 wxIndividualLayoutConstraint *result = 0 ;
56115 void *argp1 = 0 ;
56116 int res1 = 0 ;
56117 PyObject *swig_obj[1] ;
56118
56119 if (!args) SWIG_fail;
56120 swig_obj[0] = args;
56121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56122 if (!SWIG_IsOK(res1)) {
56123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56124 }
56125 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56126 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
56127 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56128 return resultobj;
56129 fail:
56130 return NULL;
56131 }
56132
56133
56134 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56135 PyObject *resultobj = 0;
56136 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56137 wxIndividualLayoutConstraint *result = 0 ;
56138 void *argp1 = 0 ;
56139 int res1 = 0 ;
56140 PyObject *swig_obj[1] ;
56141
56142 if (!args) SWIG_fail;
56143 swig_obj[0] = args;
56144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56145 if (!SWIG_IsOK(res1)) {
56146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56147 }
56148 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56149 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
56150 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56151 return resultobj;
56152 fail:
56153 return NULL;
56154 }
56155
56156
56157 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56158 PyObject *resultobj = 0;
56159 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56160 wxIndividualLayoutConstraint *result = 0 ;
56161 void *argp1 = 0 ;
56162 int res1 = 0 ;
56163 PyObject *swig_obj[1] ;
56164
56165 if (!args) SWIG_fail;
56166 swig_obj[0] = args;
56167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56168 if (!SWIG_IsOK(res1)) {
56169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56170 }
56171 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56172 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
56173 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56174 return resultobj;
56175 fail:
56176 return NULL;
56177 }
56178
56179
56180 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56181 PyObject *resultobj = 0;
56182 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56183 wxIndividualLayoutConstraint *result = 0 ;
56184 void *argp1 = 0 ;
56185 int res1 = 0 ;
56186 PyObject *swig_obj[1] ;
56187
56188 if (!args) SWIG_fail;
56189 swig_obj[0] = args;
56190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56191 if (!SWIG_IsOK(res1)) {
56192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56193 }
56194 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56195 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
56196 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56197 return resultobj;
56198 fail:
56199 return NULL;
56200 }
56201
56202
56203 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56204 PyObject *resultobj = 0;
56205 wxLayoutConstraints *result = 0 ;
56206
56207 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
56208 {
56209 PyThreadState* __tstate = wxPyBeginAllowThreads();
56210 result = (wxLayoutConstraints *)new wxLayoutConstraints();
56211 wxPyEndAllowThreads(__tstate);
56212 if (PyErr_Occurred()) SWIG_fail;
56213 }
56214 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
56215 return resultobj;
56216 fail:
56217 return NULL;
56218 }
56219
56220
56221 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56222 PyObject *resultobj = 0;
56223 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56224 void *argp1 = 0 ;
56225 int res1 = 0 ;
56226 PyObject *swig_obj[1] ;
56227
56228 if (!args) SWIG_fail;
56229 swig_obj[0] = args;
56230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
56231 if (!SWIG_IsOK(res1)) {
56232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56233 }
56234 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56235 {
56236 PyThreadState* __tstate = wxPyBeginAllowThreads();
56237 delete arg1;
56238
56239 wxPyEndAllowThreads(__tstate);
56240 if (PyErr_Occurred()) SWIG_fail;
56241 }
56242 resultobj = SWIG_Py_Void();
56243 return resultobj;
56244 fail:
56245 return NULL;
56246 }
56247
56248
56249 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56250 PyObject *resultobj = 0;
56251 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56252 wxWindow *arg2 = (wxWindow *) 0 ;
56253 int *arg3 = (int *) 0 ;
56254 bool result;
56255 void *argp1 = 0 ;
56256 int res1 = 0 ;
56257 void *argp2 = 0 ;
56258 int res2 = 0 ;
56259 int temp3 ;
56260 int res3 = SWIG_TMPOBJ ;
56261 PyObject * obj0 = 0 ;
56262 PyObject * obj1 = 0 ;
56263 char * kwnames[] = {
56264 (char *) "self",(char *) "win", NULL
56265 };
56266
56267 arg3 = &temp3;
56268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
56269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56270 if (!SWIG_IsOK(res1)) {
56271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56272 }
56273 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56274 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56275 if (!SWIG_IsOK(res2)) {
56276 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
56277 }
56278 arg2 = reinterpret_cast< wxWindow * >(argp2);
56279 {
56280 PyThreadState* __tstate = wxPyBeginAllowThreads();
56281 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
56282 wxPyEndAllowThreads(__tstate);
56283 if (PyErr_Occurred()) SWIG_fail;
56284 }
56285 {
56286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56287 }
56288 if (SWIG_IsTmpObj(res3)) {
56289 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
56290 } else {
56291 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
56292 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
56293 }
56294 return resultobj;
56295 fail:
56296 return NULL;
56297 }
56298
56299
56300 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56301 PyObject *resultobj = 0;
56302 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56303 bool result;
56304 void *argp1 = 0 ;
56305 int res1 = 0 ;
56306 PyObject *swig_obj[1] ;
56307
56308 if (!args) SWIG_fail;
56309 swig_obj[0] = args;
56310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56311 if (!SWIG_IsOK(res1)) {
56312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
56313 }
56314 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56315 {
56316 PyThreadState* __tstate = wxPyBeginAllowThreads();
56317 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
56318 wxPyEndAllowThreads(__tstate);
56319 if (PyErr_Occurred()) SWIG_fail;
56320 }
56321 {
56322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56323 }
56324 return resultobj;
56325 fail:
56326 return NULL;
56327 }
56328
56329
56330 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56331 PyObject *obj;
56332 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56333 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
56334 return SWIG_Py_Void();
56335 }
56336
56337 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56338 return SWIG_Python_InitShadowInstance(args);
56339 }
56340
56341 static PyMethodDef SwigMethods[] = {
56342 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
56343 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
56344 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
56345 { (char *)"Object_IsSameAs", (PyCFunction) _wrap_Object_IsSameAs, METH_VARARGS | METH_KEYWORDS, NULL},
56346 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
56347 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
56348 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
56349 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
56350 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
56351 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56352 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
56353 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56354 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56355 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56356 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56357 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
56358 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
56359 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
56360 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
56361 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56362 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56363 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56364 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56365 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
56366 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
56367 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
56368 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
56369 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
56370 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
56371 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
56372 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
56373 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
56374 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
56375 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
56376 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56377 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
56378 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56379 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56380 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56381 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56382 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56383 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
56384 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
56385 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
56386 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
56387 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
56388 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
56389 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
56390 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
56391 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
56392 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56393 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56394 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56395 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56396 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56397 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56398 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56399 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
56400 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
56401 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
56402 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
56403 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
56404 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
56405 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
56406 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
56407 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
56408 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
56409 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
56410 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
56411 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
56412 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56413 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
56414 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56415 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
56416 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56417 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
56418 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
56419 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
56420 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
56421 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56422 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
56423 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
56424 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
56425 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
56426 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
56427 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56428 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
56429 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
56430 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
56431 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
56432 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56433 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56434 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56435 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56436 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
56437 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
56438 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
56439 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56440 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56441 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56442 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56443 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56444 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56445 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56446 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
56447 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56448 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56449 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56450 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
56451 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
56452 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
56453 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
56454 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
56455 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
56456 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
56457 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
56458 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
56459 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56460 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
56461 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
56462 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
56463 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
56464 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
56465 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
56466 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56467 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
56468 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
56469 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
56470 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
56471 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
56472 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
56473 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
56474 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
56475 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
56476 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56477 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56478 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
56479 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56480 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56481 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
56482 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
56483 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56484 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56485 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
56486 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
56487 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
56488 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
56489 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56490 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
56491 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
56492 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
56493 { (char *)"new_Rect2D", (PyCFunction) _wrap_new_Rect2D, METH_VARARGS | METH_KEYWORDS, NULL},
56494 { (char *)"delete_Rect2D", (PyCFunction)_wrap_delete_Rect2D, METH_O, NULL},
56495 { (char *)"Rect2D_GetPosition", (PyCFunction)_wrap_Rect2D_GetPosition, METH_O, NULL},
56496 { (char *)"Rect2D_GetSize", (PyCFunction)_wrap_Rect2D_GetSize, METH_O, NULL},
56497 { (char *)"Rect2D_GetLeft", (PyCFunction)_wrap_Rect2D_GetLeft, METH_O, NULL},
56498 { (char *)"Rect2D_SetLeft", (PyCFunction) _wrap_Rect2D_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56499 { (char *)"Rect2D_MoveLeftTo", (PyCFunction) _wrap_Rect2D_MoveLeftTo, METH_VARARGS | METH_KEYWORDS, NULL},
56500 { (char *)"Rect2D_GetTop", (PyCFunction)_wrap_Rect2D_GetTop, METH_O, NULL},
56501 { (char *)"Rect2D_SetTop", (PyCFunction) _wrap_Rect2D_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56502 { (char *)"Rect2D_MoveTopTo", (PyCFunction) _wrap_Rect2D_MoveTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56503 { (char *)"Rect2D_GetBottom", (PyCFunction)_wrap_Rect2D_GetBottom, METH_O, NULL},
56504 { (char *)"Rect2D_SetBottom", (PyCFunction) _wrap_Rect2D_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56505 { (char *)"Rect2D_MoveBottomTo", (PyCFunction) _wrap_Rect2D_MoveBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56506 { (char *)"Rect2D_GetRight", (PyCFunction)_wrap_Rect2D_GetRight, METH_O, NULL},
56507 { (char *)"Rect2D_SetRight", (PyCFunction) _wrap_Rect2D_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56508 { (char *)"Rect2D_MoveRightTo", (PyCFunction) _wrap_Rect2D_MoveRightTo, METH_VARARGS | METH_KEYWORDS, NULL},
56509 { (char *)"Rect2D_GetLeftTop", (PyCFunction)_wrap_Rect2D_GetLeftTop, METH_O, NULL},
56510 { (char *)"Rect2D_SetLeftTop", (PyCFunction) _wrap_Rect2D_SetLeftTop, METH_VARARGS | METH_KEYWORDS, NULL},
56511 { (char *)"Rect2D_MoveLeftTopTo", (PyCFunction) _wrap_Rect2D_MoveLeftTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56512 { (char *)"Rect2D_GetLeftBottom", (PyCFunction)_wrap_Rect2D_GetLeftBottom, METH_O, NULL},
56513 { (char *)"Rect2D_SetLeftBottom", (PyCFunction) _wrap_Rect2D_SetLeftBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56514 { (char *)"Rect2D_MoveLeftBottomTo", (PyCFunction) _wrap_Rect2D_MoveLeftBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56515 { (char *)"Rect2D_GetRightTop", (PyCFunction)_wrap_Rect2D_GetRightTop, METH_O, NULL},
56516 { (char *)"Rect2D_SetRightTop", (PyCFunction) _wrap_Rect2D_SetRightTop, METH_VARARGS | METH_KEYWORDS, NULL},
56517 { (char *)"Rect2D_MoveRightTopTo", (PyCFunction) _wrap_Rect2D_MoveRightTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56518 { (char *)"Rect2D_GetRightBottom", (PyCFunction)_wrap_Rect2D_GetRightBottom, METH_O, NULL},
56519 { (char *)"Rect2D_SetRightBottom", (PyCFunction) _wrap_Rect2D_SetRightBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56520 { (char *)"Rect2D_MoveRightBottomTo", (PyCFunction) _wrap_Rect2D_MoveRightBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56521 { (char *)"Rect2D_GetCentre", (PyCFunction)_wrap_Rect2D_GetCentre, METH_O, NULL},
56522 { (char *)"Rect2D_SetCentre", (PyCFunction) _wrap_Rect2D_SetCentre, METH_VARARGS | METH_KEYWORDS, NULL},
56523 { (char *)"Rect2D_MoveCentreTo", (PyCFunction) _wrap_Rect2D_MoveCentreTo, METH_VARARGS | METH_KEYWORDS, NULL},
56524 { (char *)"Rect2D_GetOutcode", (PyCFunction) _wrap_Rect2D_GetOutcode, METH_VARARGS | METH_KEYWORDS, NULL},
56525 { (char *)"Rect2D_Contains", (PyCFunction) _wrap_Rect2D_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56526 { (char *)"Rect2D_ContainsRect", (PyCFunction) _wrap_Rect2D_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56527 { (char *)"Rect2D_IsEmpty", (PyCFunction)_wrap_Rect2D_IsEmpty, METH_O, NULL},
56528 { (char *)"Rect2D_HaveEqualSize", (PyCFunction) _wrap_Rect2D_HaveEqualSize, METH_VARARGS | METH_KEYWORDS, NULL},
56529 { (char *)"Rect2D_Inset", _wrap_Rect2D_Inset, METH_VARARGS, NULL},
56530 { (char *)"Rect2D_Offset", (PyCFunction) _wrap_Rect2D_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56531 { (char *)"Rect2D_ConstrainTo", (PyCFunction) _wrap_Rect2D_ConstrainTo, METH_VARARGS | METH_KEYWORDS, NULL},
56532 { (char *)"Rect2D_Interpolate", (PyCFunction) _wrap_Rect2D_Interpolate, METH_VARARGS | METH_KEYWORDS, NULL},
56533 { (char *)"Rect2D_Intersect", (PyCFunction) _wrap_Rect2D_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56534 { (char *)"Rect2D_CreateIntersection", (PyCFunction) _wrap_Rect2D_CreateIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
56535 { (char *)"Rect2D_Intersects", (PyCFunction) _wrap_Rect2D_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56536 { (char *)"Rect2D_Union", (PyCFunction) _wrap_Rect2D_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56537 { (char *)"Rect2D_CreateUnion", (PyCFunction) _wrap_Rect2D_CreateUnion, METH_VARARGS | METH_KEYWORDS, NULL},
56538 { (char *)"Rect2D_Scale", _wrap_Rect2D_Scale, METH_VARARGS, NULL},
56539 { (char *)"Rect2D___eq__", (PyCFunction) _wrap_Rect2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56540 { (char *)"Rect2D___ne__", (PyCFunction) _wrap_Rect2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56541 { (char *)"Rect2D_x_set", _wrap_Rect2D_x_set, METH_VARARGS, NULL},
56542 { (char *)"Rect2D_x_get", (PyCFunction)_wrap_Rect2D_x_get, METH_O, NULL},
56543 { (char *)"Rect2D_y_set", _wrap_Rect2D_y_set, METH_VARARGS, NULL},
56544 { (char *)"Rect2D_y_get", (PyCFunction)_wrap_Rect2D_y_get, METH_O, NULL},
56545 { (char *)"Rect2D_width_set", _wrap_Rect2D_width_set, METH_VARARGS, NULL},
56546 { (char *)"Rect2D_width_get", (PyCFunction)_wrap_Rect2D_width_get, METH_O, NULL},
56547 { (char *)"Rect2D_height_set", _wrap_Rect2D_height_set, METH_VARARGS, NULL},
56548 { (char *)"Rect2D_height_get", (PyCFunction)_wrap_Rect2D_height_get, METH_O, NULL},
56549 { (char *)"Rect2D_Set", (PyCFunction) _wrap_Rect2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56550 { (char *)"Rect2D_Get", (PyCFunction)_wrap_Rect2D_Get, METH_O, NULL},
56551 { (char *)"Rect2D_swigregister", Rect2D_swigregister, METH_VARARGS, NULL},
56552 { (char *)"Rect2D_swiginit", Rect2D_swiginit, METH_VARARGS, NULL},
56553 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
56554 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
56555 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
56556 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
56557 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
56558 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
56559 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
56560 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
56561 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
56562 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
56563 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
56564 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
56565 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
56566 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
56567 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
56568 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
56569 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
56570 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
56571 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
56572 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
56573 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
56574 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
56575 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
56576 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
56577 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
56578 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
56579 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
56580 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
56581 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
56582 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
56583 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
56584 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
56585 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
56586 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
56587 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
56588 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
56589 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56590 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56591 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56592 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56593 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
56594 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
56595 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56596 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
56597 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56598 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
56599 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
56600 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
56601 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
56602 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
56603 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
56604 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
56605 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56606 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56607 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
56608 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56609 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56610 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
56611 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
56612 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
56613 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
56614 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
56615 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
56616 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56617 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56618 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
56619 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
56620 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
56621 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56622 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56623 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56624 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
56625 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
56626 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
56627 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
56628 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56629 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
56630 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
56631 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56632 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56633 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56634 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56635 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
56636 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
56637 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
56638 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
56639 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
56640 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
56641 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
56642 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56643 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56644 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
56645 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
56646 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
56647 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
56648 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
56649 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
56650 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
56651 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
56652 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
56653 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
56654 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
56655 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56656 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
56657 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56658 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
56659 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
56660 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
56661 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
56662 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
56663 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
56664 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
56665 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
56666 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
56667 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
56668 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
56669 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
56670 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
56671 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
56672 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
56673 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
56674 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
56675 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
56676 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
56677 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
56678 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
56679 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
56680 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
56681 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
56682 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
56683 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
56684 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
56685 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56686 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
56687 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56688 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
56689 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
56690 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56691 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
56692 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
56693 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
56694 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
56695 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
56696 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
56697 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
56698 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
56699 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56700 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
56701 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
56702 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
56703 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
56704 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56705 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56706 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
56707 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
56708 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
56709 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56710 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
56711 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56712 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
56713 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56714 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
56715 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
56716 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56717 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56718 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56719 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56720 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56721 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
56722 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
56723 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
56724 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
56725 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
56726 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
56727 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56728 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
56729 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
56730 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
56731 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
56732 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
56733 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56734 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
56735 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
56736 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
56737 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56738 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
56739 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
56740 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
56741 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
56742 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
56743 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
56744 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
56745 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
56746 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
56747 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
56748 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
56749 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
56750 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
56751 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56752 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56753 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56754 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56755 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
56756 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
56757 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
56758 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56759 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56760 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56761 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
56762 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
56763 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56764 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56765 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
56766 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
56767 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56768 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
56769 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
56770 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56771 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
56772 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
56773 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
56774 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
56775 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
56776 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
56777 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
56778 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
56779 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
56780 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
56781 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
56782 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
56783 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
56784 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
56785 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
56786 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
56787 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
56788 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
56789 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
56790 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
56791 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
56792 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
56793 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
56794 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
56795 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
56796 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
56797 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
56798 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
56799 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
56800 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
56801 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
56802 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
56803 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
56804 { (char *)"new_TGAHandler", (PyCFunction)_wrap_new_TGAHandler, METH_NOARGS, NULL},
56805 { (char *)"TGAHandler_swigregister", TGAHandler_swigregister, METH_VARARGS, NULL},
56806 { (char *)"TGAHandler_swiginit", TGAHandler_swiginit, METH_VARARGS, NULL},
56807 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
56808 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
56809 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
56810 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
56811 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
56812 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56813 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56814 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
56815 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
56816 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56817 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56818 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
56819 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
56820 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
56821 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56822 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
56823 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
56824 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
56825 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
56826 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
56827 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
56828 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
56829 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
56830 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
56831 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
56832 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
56833 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
56834 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
56835 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
56836 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
56837 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
56838 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
56839 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
56840 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
56841 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
56842 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
56843 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
56844 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
56845 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
56846 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
56847 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
56848 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
56849 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
56850 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56851 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
56852 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
56853 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
56854 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
56855 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
56856 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
56857 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
56858 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
56859 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
56860 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
56861 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
56862 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
56863 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
56864 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
56865 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56866 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
56867 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
56868 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
56869 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
56870 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
56871 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56872 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
56873 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
56874 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
56875 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56876 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
56877 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
56878 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56879 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
56880 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
56881 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
56882 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56883 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
56884 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
56885 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56886 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
56887 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
56888 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
56889 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
56890 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
56891 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
56892 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
56893 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
56894 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
56895 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
56896 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
56897 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
56898 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
56899 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
56900 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
56901 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
56902 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
56903 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
56904 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
56905 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
56906 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
56907 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
56908 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
56909 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
56910 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
56911 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
56912 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
56913 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
56914 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
56915 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
56916 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56917 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
56918 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
56919 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
56920 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
56921 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
56922 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
56923 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
56924 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
56925 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
56926 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
56927 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
56928 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
56929 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
56930 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
56931 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
56932 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
56933 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
56934 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
56935 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
56936 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
56937 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
56938 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
56939 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
56940 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
56941 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
56942 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
56943 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
56944 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
56945 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
56946 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
56947 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
56948 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
56949 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56950 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
56951 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
56952 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
56953 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
56954 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
56955 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
56956 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
56957 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56958 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
56959 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
56960 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
56961 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
56962 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
56963 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
56964 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
56965 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
56966 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
56967 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
56968 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
56969 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
56970 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
56971 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
56972 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
56973 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
56974 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
56975 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
56976 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
56977 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
56978 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
56979 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
56980 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
56981 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
56982 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
56983 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
56984 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
56985 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
56986 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
56987 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
56988 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
56989 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
56990 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
56991 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
56992 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
56993 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
56994 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
56995 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
56996 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56997 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
56998 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
56999 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57000 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57001 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
57002 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
57003 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
57004 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
57005 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
57006 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
57007 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57008 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
57009 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
57010 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57011 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57012 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
57013 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
57014 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57015 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
57016 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
57017 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57018 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
57019 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
57020 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57021 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
57022 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
57023 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
57024 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57025 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
57026 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57027 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
57028 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
57029 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57030 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
57031 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
57032 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
57033 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57034 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
57035 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
57036 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
57037 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57038 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
57039 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
57040 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57041 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
57042 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
57043 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
57044 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
57045 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
57046 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57047 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
57048 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
57049 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
57050 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
57051 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
57052 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
57053 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
57054 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
57055 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57056 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
57057 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
57058 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
57059 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
57060 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57061 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
57062 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
57063 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
57064 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57065 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
57066 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
57067 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
57068 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
57069 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
57070 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
57071 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57072 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
57073 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
57074 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
57075 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
57076 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
57077 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
57078 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
57079 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
57080 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57081 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57082 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57083 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57084 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
57085 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
57086 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
57087 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
57088 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57089 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
57090 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
57091 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
57092 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
57093 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
57094 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
57095 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57096 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
57097 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
57098 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
57099 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57100 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
57101 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
57102 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
57103 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
57104 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
57105 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57106 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57107 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
57108 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
57109 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
57110 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57111 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
57112 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
57113 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
57114 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
57115 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
57116 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
57117 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57118 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
57119 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
57120 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
57121 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
57122 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
57123 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
57124 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
57125 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
57126 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
57127 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57128 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
57129 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
57130 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
57131 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57132 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
57133 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
57134 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
57135 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57136 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
57137 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57138 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
57139 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
57140 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
57141 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
57142 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
57143 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57144 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
57145 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
57146 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
57147 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
57148 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57149 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
57150 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
57151 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57152 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
57153 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57154 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
57155 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
57156 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
57157 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57158 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
57159 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57160 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
57161 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
57162 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
57163 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57164 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
57165 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
57166 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
57167 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
57168 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
57169 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
57170 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57171 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
57172 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
57173 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
57174 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
57175 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
57176 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
57177 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
57178 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
57179 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
57180 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
57181 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
57182 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
57183 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
57184 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
57185 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
57186 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
57187 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
57188 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
57189 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
57190 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
57191 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57192 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
57193 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
57194 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
57195 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
57196 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
57197 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
57198 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
57199 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
57200 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
57201 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
57202 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
57203 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
57204 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
57205 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
57206 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
57207 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57208 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57209 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57210 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
57211 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
57212 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
57213 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
57214 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
57215 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
57216 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
57217 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
57218 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
57219 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
57220 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
57221 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57222 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
57223 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
57224 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
57225 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
57226 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
57227 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
57228 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
57229 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
57230 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
57231 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
57232 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
57233 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
57234 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
57235 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
57236 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
57237 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
57238 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
57239 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
57240 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
57241 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
57242 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
57243 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57244 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57245 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
57246 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
57247 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
57248 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
57249 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
57250 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
57251 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
57252 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
57253 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57254 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
57255 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
57256 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
57257 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
57258 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
57259 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
57260 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
57261 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
57262 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
57263 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
57264 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
57265 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
57266 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
57267 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
57268 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
57269 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
57270 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
57271 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57272 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
57273 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
57274 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
57275 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
57276 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57277 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
57278 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
57279 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
57280 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
57281 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
57282 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57283 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
57284 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
57285 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57286 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57287 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
57288 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57289 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57290 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57291 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
57292 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57293 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57294 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
57295 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
57296 { (char *)"Window_SetInitialSize", (PyCFunction) _wrap_Window_SetInitialSize, METH_VARARGS | METH_KEYWORDS, NULL},
57297 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
57298 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
57299 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
57300 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57301 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
57302 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
57303 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
57304 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
57305 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
57306 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
57307 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
57308 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
57309 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
57310 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
57311 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
57312 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
57313 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
57314 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
57315 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
57316 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
57317 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
57318 { (char *)"Window_GetEffectiveMinSize", (PyCFunction)_wrap_Window_GetEffectiveMinSize, METH_O, NULL},
57319 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
57320 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
57321 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
57322 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
57323 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57324 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57325 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57326 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57327 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
57328 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
57329 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57330 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
57331 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
57332 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
57333 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
57334 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
57335 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
57336 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57337 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
57338 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
57339 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
57340 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57341 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
57342 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57343 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
57344 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
57345 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
57346 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
57347 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57348 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
57349 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57350 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
57351 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57352 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
57353 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
57354 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57355 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
57356 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
57357 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
57358 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
57359 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
57360 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
57361 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
57362 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57363 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57364 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
57365 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
57366 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
57367 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
57368 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
57369 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
57370 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
57371 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
57372 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57373 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57374 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
57375 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57376 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57377 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57378 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57379 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
57380 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
57381 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
57382 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
57383 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
57384 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
57385 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57386 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
57387 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57388 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57389 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57390 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57391 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
57392 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
57393 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57394 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57395 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
57396 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
57397 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
57398 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
57399 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
57400 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
57401 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
57402 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
57403 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
57404 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
57405 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
57406 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
57407 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
57408 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
57409 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
57410 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
57411 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
57412 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57413 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
57414 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
57415 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57416 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57417 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57418 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57419 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57420 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
57421 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
57422 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
57423 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
57424 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57425 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
57426 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
57427 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
57428 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
57429 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57430 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
57431 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
57432 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
57433 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
57434 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
57435 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
57436 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57437 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57438 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
57439 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
57440 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
57441 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
57442 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
57443 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
57444 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
57445 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
57446 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
57447 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57448 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
57449 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
57450 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
57451 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
57452 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57453 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57454 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57455 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57456 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
57457 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
57458 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57459 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
57460 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
57461 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
57462 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
57463 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
57464 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
57465 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
57466 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
57467 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57468 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
57469 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
57470 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
57471 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
57472 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
57473 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
57474 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
57475 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
57476 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
57477 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
57478 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
57479 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
57480 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57481 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
57482 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
57483 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57484 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
57485 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
57486 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
57487 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
57488 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
57489 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
57490 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
57491 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57492 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57493 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57494 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
57495 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
57496 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
57497 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
57498 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
57499 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
57500 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
57501 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
57502 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57503 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
57504 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
57505 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
57506 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
57507 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
57508 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57509 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
57510 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
57511 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
57512 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57513 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
57514 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57515 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57516 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57517 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57518 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
57519 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57520 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57521 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
57522 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57523 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
57524 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57525 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57526 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57527 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57528 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
57529 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57530 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57531 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57532 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57533 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
57534 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57535 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
57536 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
57537 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
57538 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
57539 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
57540 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
57541 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
57542 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57543 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57544 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57545 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57546 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57547 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57548 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57549 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57550 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57551 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57552 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
57553 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
57554 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57555 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
57556 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57557 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
57558 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
57559 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
57560 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
57561 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57562 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
57563 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
57564 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
57565 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
57566 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
57567 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
57568 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
57569 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57570 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57571 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
57572 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57573 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
57574 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57575 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
57576 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
57577 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57578 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57579 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57580 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57581 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57582 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57583 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57584 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57585 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57586 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57587 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57588 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57589 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57590 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
57591 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
57592 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57593 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
57594 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
57595 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57596 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
57597 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
57598 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
57599 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57600 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
57601 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
57602 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57603 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57604 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
57605 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
57606 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57607 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
57608 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
57609 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
57610 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
57611 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
57612 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
57613 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
57614 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
57615 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57616 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
57617 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57618 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
57619 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57620 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
57621 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
57622 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
57623 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
57624 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
57625 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
57626 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57627 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
57628 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57629 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
57630 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
57631 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
57632 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57633 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
57634 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
57635 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57636 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
57637 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
57638 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
57639 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
57640 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
57641 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
57642 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
57643 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
57644 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
57645 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
57646 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
57647 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57648 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
57649 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
57650 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
57651 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57652 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
57653 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
57654 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57655 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
57656 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57657 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
57658 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57659 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57660 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57661 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
57662 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
57663 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
57664 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
57665 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
57666 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
57667 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57668 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
57669 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57670 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
57671 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
57672 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
57673 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
57674 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
57675 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
57676 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57677 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57678 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57679 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
57680 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
57681 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
57682 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
57683 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57684 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
57685 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
57686 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
57687 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
57688 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
57689 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
57690 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
57691 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
57692 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
57693 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
57694 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
57695 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
57696 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
57697 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57698 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
57699 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
57700 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
57701 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
57702 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57703 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
57704 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57705 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
57706 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57707 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57708 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
57709 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
57710 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
57711 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
57712 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
57713 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
57714 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
57715 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57716 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57717 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57718 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57719 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57720 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
57721 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
57722 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57723 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
57724 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57725 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
57726 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57727 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
57728 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57729 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57730 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57731 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57732 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57733 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
57734 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
57735 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
57736 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
57737 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
57738 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
57739 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
57740 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
57741 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57742 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57743 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
57744 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
57745 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
57746 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57747 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
57748 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
57749 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
57750 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
57751 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57752 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
57753 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
57754 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57755 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
57756 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
57757 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
57758 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
57759 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57760 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
57761 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
57762 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
57763 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57764 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
57765 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
57766 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
57767 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
57768 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
57769 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
57770 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
57771 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
57772 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
57773 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
57774 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57775 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
57776 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
57777 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
57778 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
57779 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57780 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
57781 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
57782 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
57783 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
57784 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
57785 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
57786 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
57787 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
57788 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
57789 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
57790 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
57791 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
57792 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
57793 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
57794 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
57795 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
57796 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
57797 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
57798 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
57799 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
57800 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57801 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
57802 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
57803 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
57804 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
57805 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
57806 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57807 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57808 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57809 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
57810 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
57811 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
57812 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
57813 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
57814 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
57815 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
57816 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
57817 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
57818 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57819 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57820 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57821 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
57822 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
57823 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
57824 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
57825 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
57826 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57827 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57828 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57829 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
57830 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
57831 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
57832 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
57833 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
57834 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
57835 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
57836 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
57837 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57838 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
57839 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
57840 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57841 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57842 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57843 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
57844 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
57845 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
57846 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
57847 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
57848 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
57849 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
57850 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
57851 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57852 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57853 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
57854 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
57855 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
57856 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
57857 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57858 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
57859 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
57860 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
57861 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
57862 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
57863 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
57864 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
57865 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
57866 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
57867 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
57868 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
57869 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
57870 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
57871 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
57872 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
57873 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
57874 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
57875 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
57876 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
57877 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
57878 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
57879 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
57880 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
57881 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
57882 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
57883 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
57884 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
57885 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
57886 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
57887 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
57888 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
57889 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
57890 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
57891 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
57892 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
57893 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
57894 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
57895 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
57896 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
57897 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
57898 { NULL, NULL, 0, NULL }
57899 };
57900
57901
57902 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
57903
57904 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
57905 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
57906 }
57907 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
57908 return (void *)((wxSizer *) ((wxBoxSizer *) x));
57909 }
57910 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
57911 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
57912 }
57913 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
57914 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
57915 }
57916 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
57917 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
57918 }
57919 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
57920 return (void *)((wxSizer *) ((wxGridSizer *) x));
57921 }
57922 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
57923 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
57924 }
57925 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
57926 return (void *)((wxSizer *) ((wxPySizer *) x));
57927 }
57928 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
57929 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
57930 }
57931 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
57932 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
57933 }
57934 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
57935 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
57936 }
57937 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
57938 return (void *)((wxEvent *) ((wxMenuEvent *) x));
57939 }
57940 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
57941 return (void *)((wxEvent *) ((wxCloseEvent *) x));
57942 }
57943 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
57944 return (void *)((wxEvent *) ((wxMouseEvent *) x));
57945 }
57946 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
57947 return (void *)((wxEvent *) ((wxEraseEvent *) x));
57948 }
57949 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
57950 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
57951 }
57952 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
57953 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
57954 }
57955 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
57956 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
57957 }
57958 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
57959 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
57960 }
57961 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
57962 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
57963 }
57964 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
57965 return (void *)((wxEvent *) ((wxPyEvent *) x));
57966 }
57967 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
57968 return (void *)((wxEvent *) ((wxIdleEvent *) x));
57969 }
57970 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
57971 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
57972 }
57973 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
57974 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
57975 }
57976 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
57977 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
57978 }
57979 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
57980 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
57981 }
57982 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
57983 return (void *)((wxEvent *) ((wxActivateEvent *) x));
57984 }
57985 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
57986 return (void *)((wxEvent *) ((wxSizeEvent *) x));
57987 }
57988 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
57989 return (void *)((wxEvent *) ((wxMoveEvent *) x));
57990 }
57991 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
57992 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
57993 }
57994 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
57995 return (void *)((wxEvent *) ((wxPaintEvent *) x));
57996 }
57997 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
57998 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
57999 }
58000 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
58001 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
58002 }
58003 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
58004 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
58005 }
58006 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
58007 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
58008 }
58009 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
58010 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
58011 }
58012 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
58013 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58014 }
58015 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
58016 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
58017 }
58018 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
58019 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
58020 }
58021 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
58022 return (void *)((wxEvent *) ((wxFocusEvent *) x));
58023 }
58024 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
58025 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
58026 }
58027 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
58028 return (void *)((wxEvent *) ((wxShowEvent *) x));
58029 }
58030 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
58031 return (void *)((wxEvent *) ((wxCommandEvent *) x));
58032 }
58033 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
58034 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
58035 }
58036 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
58037 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58038 }
58039 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
58040 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
58041 }
58042 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
58043 return (void *)((wxEvent *) ((wxKeyEvent *) x));
58044 }
58045 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
58046 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
58047 }
58048 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
58049 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
58050 }
58051 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
58052 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
58053 }
58054 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
58055 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
58056 }
58057 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
58058 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
58059 }
58060 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
58061 return (void *)((wxControl *) ((wxControlWithItems *) x));
58062 }
58063 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
58064 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
58065 }
58066 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
58067 return (void *)((wxEvtHandler *) ((wxWindow *) x));
58068 }
58069 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
58070 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58071 }
58072 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
58073 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
58074 }
58075 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
58076 return (void *)((wxEvtHandler *) ((wxValidator *) x));
58077 }
58078 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
58079 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
58080 }
58081 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
58082 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
58083 }
58084 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
58085 return (void *)((wxEvtHandler *) ((wxMenu *) x));
58086 }
58087 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
58088 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
58089 }
58090 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
58091 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
58092 }
58093 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
58094 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
58095 }
58096 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
58097 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
58098 }
58099 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
58100 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
58101 }
58102 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
58103 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58104 }
58105 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
58106 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
58107 }
58108 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
58109 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
58110 }
58111 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
58112 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
58113 }
58114 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
58115 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58116 }
58117 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
58118 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58119 }
58120 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
58121 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
58122 }
58123 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
58124 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
58125 }
58126 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
58127 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
58128 }
58129 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
58130 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
58131 }
58132 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
58133 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
58134 }
58135 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
58136 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
58137 }
58138 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
58139 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
58140 }
58141 static void *_p_wxTGAHandlerTo_p_wxImageHandler(void *x) {
58142 return (void *)((wxImageHandler *) ((wxTGAHandler *) x));
58143 }
58144 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
58145 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
58146 }
58147 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
58148 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
58149 }
58150 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
58151 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
58152 }
58153 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
58154 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
58155 }
58156 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
58157 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
58158 }
58159 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
58160 return (void *)((wxObject *) ((wxSizerItem *) x));
58161 }
58162 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
58163 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
58164 }
58165 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
58166 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
58167 }
58168 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
58169 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
58170 }
58171 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
58172 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
58173 }
58174 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
58175 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
58176 }
58177 static void *_p_wxSizerTo_p_wxObject(void *x) {
58178 return (void *)((wxObject *) ((wxSizer *) x));
58179 }
58180 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
58181 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
58182 }
58183 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
58184 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
58185 }
58186 static void *_p_wxEventTo_p_wxObject(void *x) {
58187 return (void *)((wxObject *) ((wxEvent *) x));
58188 }
58189 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
58190 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
58191 }
58192 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
58193 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
58194 }
58195 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
58196 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
58197 }
58198 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
58199 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
58200 }
58201 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
58202 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
58203 }
58204 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
58205 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
58206 }
58207 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
58208 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
58209 }
58210 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
58211 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
58212 }
58213 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
58214 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58215 }
58216 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
58217 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
58218 }
58219 static void *_p_wxControlTo_p_wxObject(void *x) {
58220 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
58221 }
58222 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
58223 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
58224 }
58225 static void *_p_wxFSFileTo_p_wxObject(void *x) {
58226 return (void *)((wxObject *) ((wxFSFile *) x));
58227 }
58228 static void *_p_wxPySizerTo_p_wxObject(void *x) {
58229 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
58230 }
58231 static void *_p_wxPyEventTo_p_wxObject(void *x) {
58232 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
58233 }
58234 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
58235 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
58236 }
58237 static void *_p_wxShowEventTo_p_wxObject(void *x) {
58238 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
58239 }
58240 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
58241 return (void *)((wxObject *) ((wxMenuItem *) x));
58242 }
58243 static void *_p_wxDateEventTo_p_wxObject(void *x) {
58244 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
58245 }
58246 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
58247 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
58248 }
58249 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
58250 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
58251 }
58252 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
58253 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
58254 }
58255 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
58256 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
58257 }
58258 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
58259 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
58260 }
58261 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
58262 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
58263 }
58264 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
58265 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
58266 }
58267 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
58268 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
58269 }
58270 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
58271 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
58272 }
58273 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
58274 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
58275 }
58276 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
58277 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
58278 }
58279 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
58280 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
58281 }
58282 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
58283 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
58284 }
58285 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
58286 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58287 }
58288 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
58289 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58290 }
58291 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
58292 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
58293 }
58294 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
58295 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
58296 }
58297 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
58298 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
58299 }
58300 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
58301 return (void *)((wxObject *) ((wxImageHandler *) x));
58302 }
58303 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
58304 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
58305 }
58306 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
58307 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
58308 }
58309 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
58310 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
58311 }
58312 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
58313 return (void *)((wxObject *) ((wxEvtHandler *) x));
58314 }
58315 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
58316 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
58317 }
58318 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
58319 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
58320 }
58321 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
58322 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58323 }
58324 static void *_p_wxImageTo_p_wxObject(void *x) {
58325 return (void *)((wxObject *) ((wxImage *) x));
58326 }
58327 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
58328 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
58329 }
58330 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
58331 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58332 }
58333 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
58334 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
58335 }
58336 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
58337 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
58338 }
58339 static void *_p_wxWindowTo_p_wxObject(void *x) {
58340 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
58341 }
58342 static void *_p_wxMenuTo_p_wxObject(void *x) {
58343 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
58344 }
58345 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
58346 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
58347 }
58348 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
58349 return (void *)((wxObject *) ((wxFileSystem *) x));
58350 }
58351 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
58352 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
58353 }
58354 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
58355 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
58356 }
58357 static void *_p_wxPyAppTo_p_wxObject(void *x) {
58358 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
58359 }
58360 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
58361 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
58362 }
58363 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
58364 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
58365 }
58366 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
58367 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
58368 }
58369 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
58370 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
58371 }
58372 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
58373 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
58374 }
58375 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
58376 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
58377 }
58378 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
58379 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
58380 }
58381 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
58382 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
58383 }
58384 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
58385 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58386 }
58387 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
58388 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
58389 }
58390 static void *_p_wxValidatorTo_p_wxObject(void *x) {
58391 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
58392 }
58393 static void *_p_wxControlTo_p_wxWindow(void *x) {
58394 return (void *)((wxWindow *) ((wxControl *) x));
58395 }
58396 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
58397 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
58398 }
58399 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
58400 return (void *)((wxWindow *) ((wxMenuBar *) x));
58401 }
58402 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
58403 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
58404 }
58405 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
58406 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
58407 }
58408 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
58409 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
58410 }
58411 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
58412 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
58413 }
58414 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
58415 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
58416 }
58417 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
58418 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
58419 }
58420 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
58421 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58422 }
58423 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
58424 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
58425 }
58426 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
58427 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
58428 }
58429 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
58430 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
58431 }
58432 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
58433 return (void *)((wxValidator *) ((wxPyValidator *) x));
58434 }
58435 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
58436 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
58437 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};
58438 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
58439 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
58440 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
58441 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
58442 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
58443 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
58444 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
58445 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
58446 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
58447 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
58448 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
58449 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
58450 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
58451 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
58452 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
58453 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
58454 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
58455 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
58456 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
58457 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
58458 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
58459 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
58460 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
58461 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
58462 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
58463 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
58464 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
58465 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
58466 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
58467 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
58468 static swig_type_info _swigt__p_wxDouble = {"_p_wxDouble", "wxDouble *", 0, 0, (void*)0, 0};
58469 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
58470 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
58471 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
58472 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
58473 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
58474 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
58475 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
58476 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
58477 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
58478 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
58479 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
58480 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
58481 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
58482 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
58483 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
58484 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
58485 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
58486 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
58487 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
58488 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
58489 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
58490 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
58491 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
58492 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
58493 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
58494 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
58495 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
58496 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
58497 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
58498 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
58499 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
58500 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
58501 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
58502 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
58503 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
58504 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
58505 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
58506 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
58507 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
58508 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
58509 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
58510 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
58511 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
58512 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
58513 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
58514 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
58515 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
58516 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
58517 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
58518 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
58519 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
58520 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
58521 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
58522 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
58523 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
58524 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
58525 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
58526 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
58527 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
58528 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
58529 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
58530 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
58531 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
58532 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
58533 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
58534 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
58535 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
58536 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
58537 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
58538 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
58539 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
58540 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
58541 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
58542 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
58543 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
58544 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
58545 static swig_type_info _swigt__p_wxRect2D = {"_p_wxRect2D", "wxRect2D *", 0, 0, (void*)0, 0};
58546 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
58547 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
58548 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
58549 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
58550 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
58551 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
58552 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
58553 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
58554 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
58555 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
58556 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
58557 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
58558 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
58559 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", "wxTGAHandler *", 0, 0, (void*)0, 0};
58560 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
58561 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
58562 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
58563 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
58564 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
58565 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
58566 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
58567 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
58568 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
58569 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
58570
58571 static swig_type_info *swig_type_initial[] = {
58572 &_swigt__p_buffer,
58573 &_swigt__p_char,
58574 &_swigt__p_form_ops_t,
58575 &_swigt__p_int,
58576 &_swigt__p_long,
58577 &_swigt__p_unsigned_char,
58578 &_swigt__p_unsigned_int,
58579 &_swigt__p_unsigned_long,
58580 &_swigt__p_wxANIHandler,
58581 &_swigt__p_wxAcceleratorEntry,
58582 &_swigt__p_wxAcceleratorTable,
58583 &_swigt__p_wxActivateEvent,
58584 &_swigt__p_wxAppTraits,
58585 &_swigt__p_wxArrayString,
58586 &_swigt__p_wxBMPHandler,
58587 &_swigt__p_wxBitmap,
58588 &_swigt__p_wxBoxSizer,
58589 &_swigt__p_wxButton,
58590 &_swigt__p_wxCURHandler,
58591 &_swigt__p_wxCaret,
58592 &_swigt__p_wxChildFocusEvent,
58593 &_swigt__p_wxClipboardTextEvent,
58594 &_swigt__p_wxCloseEvent,
58595 &_swigt__p_wxColour,
58596 &_swigt__p_wxCommandEvent,
58597 &_swigt__p_wxContextMenuEvent,
58598 &_swigt__p_wxControl,
58599 &_swigt__p_wxControlWithItems,
58600 &_swigt__p_wxCursor,
58601 &_swigt__p_wxDC,
58602 &_swigt__p_wxDateEvent,
58603 &_swigt__p_wxDateTime,
58604 &_swigt__p_wxDisplayChangedEvent,
58605 &_swigt__p_wxDouble,
58606 &_swigt__p_wxDropFilesEvent,
58607 &_swigt__p_wxDuplexMode,
58608 &_swigt__p_wxEraseEvent,
58609 &_swigt__p_wxEvent,
58610 &_swigt__p_wxEventLoop,
58611 &_swigt__p_wxEventLoopActivator,
58612 &_swigt__p_wxEvtHandler,
58613 &_swigt__p_wxFSFile,
58614 &_swigt__p_wxFileSystem,
58615 &_swigt__p_wxFileSystemHandler,
58616 &_swigt__p_wxFlexGridSizer,
58617 &_swigt__p_wxFocusEvent,
58618 &_swigt__p_wxFont,
58619 &_swigt__p_wxFrame,
58620 &_swigt__p_wxGBPosition,
58621 &_swigt__p_wxGBSizerItem,
58622 &_swigt__p_wxGBSpan,
58623 &_swigt__p_wxGIFHandler,
58624 &_swigt__p_wxGridBagSizer,
58625 &_swigt__p_wxGridSizer,
58626 &_swigt__p_wxHelpEvent__Origin,
58627 &_swigt__p_wxICOHandler,
58628 &_swigt__p_wxIconizeEvent,
58629 &_swigt__p_wxIdleEvent,
58630 &_swigt__p_wxImage,
58631 &_swigt__p_wxImageHandler,
58632 &_swigt__p_wxImageHistogram,
58633 &_swigt__p_wxImage_HSVValue,
58634 &_swigt__p_wxImage_RGBValue,
58635 &_swigt__p_wxIndividualLayoutConstraint,
58636 &_swigt__p_wxInitDialogEvent,
58637 &_swigt__p_wxInputStream,
58638 &_swigt__p_wxInternetFSHandler,
58639 &_swigt__p_wxItemContainer,
58640 &_swigt__p_wxJPEGHandler,
58641 &_swigt__p_wxKeyEvent,
58642 &_swigt__p_wxLayoutConstraints,
58643 &_swigt__p_wxMaximizeEvent,
58644 &_swigt__p_wxMemoryFSHandler,
58645 &_swigt__p_wxMenu,
58646 &_swigt__p_wxMenuBar,
58647 &_swigt__p_wxMenuBarBase,
58648 &_swigt__p_wxMenuEvent,
58649 &_swigt__p_wxMenuItem,
58650 &_swigt__p_wxMouseCaptureChangedEvent,
58651 &_swigt__p_wxMouseCaptureLostEvent,
58652 &_swigt__p_wxMouseEvent,
58653 &_swigt__p_wxMoveEvent,
58654 &_swigt__p_wxNavigationKeyEvent,
58655 &_swigt__p_wxNcPaintEvent,
58656 &_swigt__p_wxNotifyEvent,
58657 &_swigt__p_wxObject,
58658 &_swigt__p_wxOutputStream,
58659 &_swigt__p_wxPCXHandler,
58660 &_swigt__p_wxPNGHandler,
58661 &_swigt__p_wxPNMHandler,
58662 &_swigt__p_wxPaintEvent,
58663 &_swigt__p_wxPaletteChangedEvent,
58664 &_swigt__p_wxPaperSize,
58665 &_swigt__p_wxPoint,
58666 &_swigt__p_wxPoint2D,
58667 &_swigt__p_wxPropagateOnce,
58668 &_swigt__p_wxPropagationDisabler,
58669 &_swigt__p_wxPyApp,
58670 &_swigt__p_wxPyCommandEvent,
58671 &_swigt__p_wxPyDropTarget,
58672 &_swigt__p_wxPyEvent,
58673 &_swigt__p_wxPyFileSystemHandler,
58674 &_swigt__p_wxPyImageHandler,
58675 &_swigt__p_wxPyInputStream,
58676 &_swigt__p_wxPySizer,
58677 &_swigt__p_wxPyValidator,
58678 &_swigt__p_wxQuantize,
58679 &_swigt__p_wxQueryNewPaletteEvent,
58680 &_swigt__p_wxRealPoint,
58681 &_swigt__p_wxRect,
58682 &_swigt__p_wxRect2D,
58683 &_swigt__p_wxRegion,
58684 &_swigt__p_wxScrollEvent,
58685 &_swigt__p_wxScrollWinEvent,
58686 &_swigt__p_wxSetCursorEvent,
58687 &_swigt__p_wxShowEvent,
58688 &_swigt__p_wxSize,
58689 &_swigt__p_wxSizeEvent,
58690 &_swigt__p_wxSizer,
58691 &_swigt__p_wxSizerItem,
58692 &_swigt__p_wxStaticBox,
58693 &_swigt__p_wxStaticBoxSizer,
58694 &_swigt__p_wxStdDialogButtonSizer,
58695 &_swigt__p_wxSysColourChangedEvent,
58696 &_swigt__p_wxTGAHandler,
58697 &_swigt__p_wxTIFFHandler,
58698 &_swigt__p_wxToolTip,
58699 &_swigt__p_wxUpdateUIEvent,
58700 &_swigt__p_wxValidator,
58701 &_swigt__p_wxVisualAttributes,
58702 &_swigt__p_wxWindow,
58703 &_swigt__p_wxWindowCreateEvent,
58704 &_swigt__p_wxWindowDestroyEvent,
58705 &_swigt__p_wxXPMHandler,
58706 &_swigt__p_wxZipFSHandler,
58707 };
58708
58709 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
58710 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
58711 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
58712 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
58713 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
58714 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
58715 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
58716 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
58717 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
58718 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
58719 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
58720 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
58721 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
58722 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
58723 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}};
58724 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
58725 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}};
58726 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
58727 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}};
58728 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
58729 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58730 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
58731 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
58732 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
58733 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}};
58734 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
58735 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}};
58736 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
58737 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
58738 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
58739 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
58740 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
58741 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58742 static swig_cast_info _swigc__p_wxDouble[] = { {&_swigt__p_wxDouble, 0, 0, 0},{0, 0, 0, 0}};
58743 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
58744 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
58745 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
58746 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}};
58747 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
58748 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
58749 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}};
58750 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
58751 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
58752 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}};
58753 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}};
58754 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58755 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
58756 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
58757 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
58758 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
58759 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
58760 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
58761 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
58762 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}};
58763 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
58764 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}};
58765 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58766 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
58767 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
58768 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}};
58769 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
58770 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
58771 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
58772 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
58773 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
58774 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
58775 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58776 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}};
58777 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
58778 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
58779 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
58780 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58781 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58782 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
58783 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
58784 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
58785 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
58786 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
58787 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58788 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
58789 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
58790 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
58791 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
58792 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
58793 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
58794 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}};
58795 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
58796 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
58797 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
58798 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
58799 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
58800 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58801 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
58802 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
58803 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
58804 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
58805 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
58806 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
58807 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
58808 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
58809 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
58810 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
58811 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
58812 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
58813 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
58814 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
58815 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
58816 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
58817 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
58818 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
58819 static swig_cast_info _swigc__p_wxRect2D[] = { {&_swigt__p_wxRect2D, 0, 0, 0},{0, 0, 0, 0}};
58820 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
58821 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
58822 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
58823 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
58824 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
58825 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
58826 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58827 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}};
58828 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}};
58829 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
58830 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
58831 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
58832 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58833 static swig_cast_info _swigc__p_wxTGAHandler[] = { {&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
58834 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
58835 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
58836 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
58837 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}};
58838 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
58839 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}};
58840 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
58841 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
58842 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
58843 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58844
58845 static swig_cast_info *swig_cast_initial[] = {
58846 _swigc__p_buffer,
58847 _swigc__p_char,
58848 _swigc__p_form_ops_t,
58849 _swigc__p_int,
58850 _swigc__p_long,
58851 _swigc__p_unsigned_char,
58852 _swigc__p_unsigned_int,
58853 _swigc__p_unsigned_long,
58854 _swigc__p_wxANIHandler,
58855 _swigc__p_wxAcceleratorEntry,
58856 _swigc__p_wxAcceleratorTable,
58857 _swigc__p_wxActivateEvent,
58858 _swigc__p_wxAppTraits,
58859 _swigc__p_wxArrayString,
58860 _swigc__p_wxBMPHandler,
58861 _swigc__p_wxBitmap,
58862 _swigc__p_wxBoxSizer,
58863 _swigc__p_wxButton,
58864 _swigc__p_wxCURHandler,
58865 _swigc__p_wxCaret,
58866 _swigc__p_wxChildFocusEvent,
58867 _swigc__p_wxClipboardTextEvent,
58868 _swigc__p_wxCloseEvent,
58869 _swigc__p_wxColour,
58870 _swigc__p_wxCommandEvent,
58871 _swigc__p_wxContextMenuEvent,
58872 _swigc__p_wxControl,
58873 _swigc__p_wxControlWithItems,
58874 _swigc__p_wxCursor,
58875 _swigc__p_wxDC,
58876 _swigc__p_wxDateEvent,
58877 _swigc__p_wxDateTime,
58878 _swigc__p_wxDisplayChangedEvent,
58879 _swigc__p_wxDouble,
58880 _swigc__p_wxDropFilesEvent,
58881 _swigc__p_wxDuplexMode,
58882 _swigc__p_wxEraseEvent,
58883 _swigc__p_wxEvent,
58884 _swigc__p_wxEventLoop,
58885 _swigc__p_wxEventLoopActivator,
58886 _swigc__p_wxEvtHandler,
58887 _swigc__p_wxFSFile,
58888 _swigc__p_wxFileSystem,
58889 _swigc__p_wxFileSystemHandler,
58890 _swigc__p_wxFlexGridSizer,
58891 _swigc__p_wxFocusEvent,
58892 _swigc__p_wxFont,
58893 _swigc__p_wxFrame,
58894 _swigc__p_wxGBPosition,
58895 _swigc__p_wxGBSizerItem,
58896 _swigc__p_wxGBSpan,
58897 _swigc__p_wxGIFHandler,
58898 _swigc__p_wxGridBagSizer,
58899 _swigc__p_wxGridSizer,
58900 _swigc__p_wxHelpEvent__Origin,
58901 _swigc__p_wxICOHandler,
58902 _swigc__p_wxIconizeEvent,
58903 _swigc__p_wxIdleEvent,
58904 _swigc__p_wxImage,
58905 _swigc__p_wxImageHandler,
58906 _swigc__p_wxImageHistogram,
58907 _swigc__p_wxImage_HSVValue,
58908 _swigc__p_wxImage_RGBValue,
58909 _swigc__p_wxIndividualLayoutConstraint,
58910 _swigc__p_wxInitDialogEvent,
58911 _swigc__p_wxInputStream,
58912 _swigc__p_wxInternetFSHandler,
58913 _swigc__p_wxItemContainer,
58914 _swigc__p_wxJPEGHandler,
58915 _swigc__p_wxKeyEvent,
58916 _swigc__p_wxLayoutConstraints,
58917 _swigc__p_wxMaximizeEvent,
58918 _swigc__p_wxMemoryFSHandler,
58919 _swigc__p_wxMenu,
58920 _swigc__p_wxMenuBar,
58921 _swigc__p_wxMenuBarBase,
58922 _swigc__p_wxMenuEvent,
58923 _swigc__p_wxMenuItem,
58924 _swigc__p_wxMouseCaptureChangedEvent,
58925 _swigc__p_wxMouseCaptureLostEvent,
58926 _swigc__p_wxMouseEvent,
58927 _swigc__p_wxMoveEvent,
58928 _swigc__p_wxNavigationKeyEvent,
58929 _swigc__p_wxNcPaintEvent,
58930 _swigc__p_wxNotifyEvent,
58931 _swigc__p_wxObject,
58932 _swigc__p_wxOutputStream,
58933 _swigc__p_wxPCXHandler,
58934 _swigc__p_wxPNGHandler,
58935 _swigc__p_wxPNMHandler,
58936 _swigc__p_wxPaintEvent,
58937 _swigc__p_wxPaletteChangedEvent,
58938 _swigc__p_wxPaperSize,
58939 _swigc__p_wxPoint,
58940 _swigc__p_wxPoint2D,
58941 _swigc__p_wxPropagateOnce,
58942 _swigc__p_wxPropagationDisabler,
58943 _swigc__p_wxPyApp,
58944 _swigc__p_wxPyCommandEvent,
58945 _swigc__p_wxPyDropTarget,
58946 _swigc__p_wxPyEvent,
58947 _swigc__p_wxPyFileSystemHandler,
58948 _swigc__p_wxPyImageHandler,
58949 _swigc__p_wxPyInputStream,
58950 _swigc__p_wxPySizer,
58951 _swigc__p_wxPyValidator,
58952 _swigc__p_wxQuantize,
58953 _swigc__p_wxQueryNewPaletteEvent,
58954 _swigc__p_wxRealPoint,
58955 _swigc__p_wxRect,
58956 _swigc__p_wxRect2D,
58957 _swigc__p_wxRegion,
58958 _swigc__p_wxScrollEvent,
58959 _swigc__p_wxScrollWinEvent,
58960 _swigc__p_wxSetCursorEvent,
58961 _swigc__p_wxShowEvent,
58962 _swigc__p_wxSize,
58963 _swigc__p_wxSizeEvent,
58964 _swigc__p_wxSizer,
58965 _swigc__p_wxSizerItem,
58966 _swigc__p_wxStaticBox,
58967 _swigc__p_wxStaticBoxSizer,
58968 _swigc__p_wxStdDialogButtonSizer,
58969 _swigc__p_wxSysColourChangedEvent,
58970 _swigc__p_wxTGAHandler,
58971 _swigc__p_wxTIFFHandler,
58972 _swigc__p_wxToolTip,
58973 _swigc__p_wxUpdateUIEvent,
58974 _swigc__p_wxValidator,
58975 _swigc__p_wxVisualAttributes,
58976 _swigc__p_wxWindow,
58977 _swigc__p_wxWindowCreateEvent,
58978 _swigc__p_wxWindowDestroyEvent,
58979 _swigc__p_wxXPMHandler,
58980 _swigc__p_wxZipFSHandler,
58981 };
58982
58983
58984 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
58985
58986 static swig_const_info swig_const_table[] = {
58987 {0, 0, 0, 0.0, 0, 0}};
58988
58989 #ifdef __cplusplus
58990 }
58991 #endif
58992 /* -----------------------------------------------------------------------------
58993 * Type initialization:
58994 * This problem is tough by the requirement that no dynamic
58995 * memory is used. Also, since swig_type_info structures store pointers to
58996 * swig_cast_info structures and swig_cast_info structures store pointers back
58997 * to swig_type_info structures, we need some lookup code at initialization.
58998 * The idea is that swig generates all the structures that are needed.
58999 * The runtime then collects these partially filled structures.
59000 * The SWIG_InitializeModule function takes these initial arrays out of
59001 * swig_module, and does all the lookup, filling in the swig_module.types
59002 * array with the correct data and linking the correct swig_cast_info
59003 * structures together.
59004 *
59005 * The generated swig_type_info structures are assigned staticly to an initial
59006 * array. We just loop though that array, and handle each type individually.
59007 * First we lookup if this type has been already loaded, and if so, use the
59008 * loaded structure instead of the generated one. Then we have to fill in the
59009 * cast linked list. The cast data is initially stored in something like a
59010 * two-dimensional array. Each row corresponds to a type (there are the same
59011 * number of rows as there are in the swig_type_initial array). Each entry in
59012 * a column is one of the swig_cast_info structures for that type.
59013 * The cast_initial array is actually an array of arrays, because each row has
59014 * a variable number of columns. So to actually build the cast linked list,
59015 * we find the array of casts associated with the type, and loop through it
59016 * adding the casts to the list. The one last trick we need to do is making
59017 * sure the type pointer in the swig_cast_info struct is correct.
59018 *
59019 * First off, we lookup the cast->type name to see if it is already loaded.
59020 * There are three cases to handle:
59021 * 1) If the cast->type has already been loaded AND the type we are adding
59022 * casting info to has not been loaded (it is in this module), THEN we
59023 * replace the cast->type pointer with the type pointer that has already
59024 * been loaded.
59025 * 2) If BOTH types (the one we are adding casting info to, and the
59026 * cast->type) are loaded, THEN the cast info has already been loaded by
59027 * the previous module so we just ignore it.
59028 * 3) Finally, if cast->type has not already been loaded, then we add that
59029 * swig_cast_info to the linked list (because the cast->type) pointer will
59030 * be correct.
59031 * ----------------------------------------------------------------------------- */
59032
59033 #ifdef __cplusplus
59034 extern "C" {
59035 #if 0
59036 } /* c-mode */
59037 #endif
59038 #endif
59039
59040 #if 0
59041 #define SWIGRUNTIME_DEBUG
59042 #endif
59043
59044 SWIGRUNTIME void
59045 SWIG_InitializeModule(void *clientdata) {
59046 size_t i;
59047 swig_module_info *module_head;
59048 static int init_run = 0;
59049
59050 clientdata = clientdata;
59051
59052 if (init_run) return;
59053 init_run = 1;
59054
59055 /* Initialize the swig_module */
59056 swig_module.type_initial = swig_type_initial;
59057 swig_module.cast_initial = swig_cast_initial;
59058
59059 /* Try and load any already created modules */
59060 module_head = SWIG_GetModule(clientdata);
59061 if (module_head) {
59062 swig_module.next = module_head->next;
59063 module_head->next = &swig_module;
59064 } else {
59065 /* This is the first module loaded */
59066 swig_module.next = &swig_module;
59067 SWIG_SetModule(clientdata, &swig_module);
59068 }
59069
59070 /* Now work on filling in swig_module.types */
59071 #ifdef SWIGRUNTIME_DEBUG
59072 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
59073 #endif
59074 for (i = 0; i < swig_module.size; ++i) {
59075 swig_type_info *type = 0;
59076 swig_type_info *ret;
59077 swig_cast_info *cast;
59078
59079 #ifdef SWIGRUNTIME_DEBUG
59080 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59081 #endif
59082
59083 /* if there is another module already loaded */
59084 if (swig_module.next != &swig_module) {
59085 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
59086 }
59087 if (type) {
59088 /* Overwrite clientdata field */
59089 #ifdef SWIGRUNTIME_DEBUG
59090 printf("SWIG_InitializeModule: found type %s\n", type->name);
59091 #endif
59092 if (swig_module.type_initial[i]->clientdata) {
59093 type->clientdata = swig_module.type_initial[i]->clientdata;
59094 #ifdef SWIGRUNTIME_DEBUG
59095 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
59096 #endif
59097 }
59098 } else {
59099 type = swig_module.type_initial[i];
59100 }
59101
59102 /* Insert casting types */
59103 cast = swig_module.cast_initial[i];
59104 while (cast->type) {
59105 /* Don't need to add information already in the list */
59106 ret = 0;
59107 #ifdef SWIGRUNTIME_DEBUG
59108 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
59109 #endif
59110 if (swig_module.next != &swig_module) {
59111 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
59112 #ifdef SWIGRUNTIME_DEBUG
59113 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
59114 #endif
59115 }
59116 if (ret) {
59117 if (type == swig_module.type_initial[i]) {
59118 #ifdef SWIGRUNTIME_DEBUG
59119 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
59120 #endif
59121 cast->type = ret;
59122 ret = 0;
59123 } else {
59124 /* Check for casting already in the list */
59125 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
59126 #ifdef SWIGRUNTIME_DEBUG
59127 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
59128 #endif
59129 if (!ocast) ret = 0;
59130 }
59131 }
59132
59133 if (!ret) {
59134 #ifdef SWIGRUNTIME_DEBUG
59135 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
59136 #endif
59137 if (type->cast) {
59138 type->cast->prev = cast;
59139 cast->next = type->cast;
59140 }
59141 type->cast = cast;
59142 }
59143 cast++;
59144 }
59145 /* Set entry in modules->types array equal to the type */
59146 swig_module.types[i] = type;
59147 }
59148 swig_module.types[i] = 0;
59149
59150 #ifdef SWIGRUNTIME_DEBUG
59151 printf("**** SWIG_InitializeModule: Cast List ******\n");
59152 for (i = 0; i < swig_module.size; ++i) {
59153 int j = 0;
59154 swig_cast_info *cast = swig_module.cast_initial[i];
59155 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59156 while (cast->type) {
59157 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
59158 cast++;
59159 ++j;
59160 }
59161 printf("---- Total casts: %d\n",j);
59162 }
59163 printf("**** SWIG_InitializeModule: Cast List ******\n");
59164 #endif
59165 }
59166
59167 /* This function will propagate the clientdata field of type to
59168 * any new swig_type_info structures that have been added into the list
59169 * of equivalent types. It is like calling
59170 * SWIG_TypeClientData(type, clientdata) a second time.
59171 */
59172 SWIGRUNTIME void
59173 SWIG_PropagateClientData(void) {
59174 size_t i;
59175 swig_cast_info *equiv;
59176 static int init_run = 0;
59177
59178 if (init_run) return;
59179 init_run = 1;
59180
59181 for (i = 0; i < swig_module.size; i++) {
59182 if (swig_module.types[i]->clientdata) {
59183 equiv = swig_module.types[i]->cast;
59184 while (equiv) {
59185 if (!equiv->converter) {
59186 if (equiv->type && !equiv->type->clientdata)
59187 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
59188 }
59189 equiv = equiv->next;
59190 }
59191 }
59192 }
59193 }
59194
59195 #ifdef __cplusplus
59196 #if 0
59197 {
59198 /* c-mode */
59199 #endif
59200 }
59201 #endif
59202
59203
59204
59205 #ifdef __cplusplus
59206 extern "C" {
59207 #endif
59208
59209 /* Python-specific SWIG API */
59210 #define SWIG_newvarlink() SWIG_Python_newvarlink()
59211 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
59212 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
59213
59214 /* -----------------------------------------------------------------------------
59215 * global variable support code.
59216 * ----------------------------------------------------------------------------- */
59217
59218 typedef struct swig_globalvar {
59219 char *name; /* Name of global variable */
59220 PyObject *(*get_attr)(void); /* Return the current value */
59221 int (*set_attr)(PyObject *); /* Set the value */
59222 struct swig_globalvar *next;
59223 } swig_globalvar;
59224
59225 typedef struct swig_varlinkobject {
59226 PyObject_HEAD
59227 swig_globalvar *vars;
59228 } swig_varlinkobject;
59229
59230 SWIGINTERN PyObject *
59231 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
59232 return PyString_FromString("<Swig global variables>");
59233 }
59234
59235 SWIGINTERN PyObject *
59236 swig_varlink_str(swig_varlinkobject *v) {
59237 PyObject *str = PyString_FromString("(");
59238 swig_globalvar *var;
59239 for (var = v->vars; var; var=var->next) {
59240 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
59241 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
59242 }
59243 PyString_ConcatAndDel(&str,PyString_FromString(")"));
59244 return str;
59245 }
59246
59247 SWIGINTERN int
59248 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
59249 PyObject *str = swig_varlink_str(v);
59250 fprintf(fp,"Swig global variables ");
59251 fprintf(fp,"%s\n", PyString_AsString(str));
59252 Py_DECREF(str);
59253 return 0;
59254 }
59255
59256 SWIGINTERN void
59257 swig_varlink_dealloc(swig_varlinkobject *v) {
59258 swig_globalvar *var = v->vars;
59259 while (var) {
59260 swig_globalvar *n = var->next;
59261 free(var->name);
59262 free(var);
59263 var = n;
59264 }
59265 }
59266
59267 SWIGINTERN PyObject *
59268 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
59269 PyObject *res = NULL;
59270 swig_globalvar *var = v->vars;
59271 while (var) {
59272 if (strcmp(var->name,n) == 0) {
59273 res = (*var->get_attr)();
59274 break;
59275 }
59276 var = var->next;
59277 }
59278 if (res == NULL && !PyErr_Occurred()) {
59279 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59280 }
59281 return res;
59282 }
59283
59284 SWIGINTERN int
59285 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
59286 int res = 1;
59287 swig_globalvar *var = v->vars;
59288 while (var) {
59289 if (strcmp(var->name,n) == 0) {
59290 res = (*var->set_attr)(p);
59291 break;
59292 }
59293 var = var->next;
59294 }
59295 if (res == 1 && !PyErr_Occurred()) {
59296 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59297 }
59298 return res;
59299 }
59300
59301 SWIGINTERN PyTypeObject*
59302 swig_varlink_type(void) {
59303 static char varlink__doc__[] = "Swig var link object";
59304 static PyTypeObject varlink_type;
59305 static int type_init = 0;
59306 if (!type_init) {
59307 const PyTypeObject tmp
59308 = {
59309 PyObject_HEAD_INIT(NULL)
59310 0, /* Number of items in variable part (ob_size) */
59311 (char *)"swigvarlink", /* Type name (tp_name) */
59312 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
59313 0, /* Itemsize (tp_itemsize) */
59314 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
59315 (printfunc) swig_varlink_print, /* Print (tp_print) */
59316 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
59317 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
59318 0, /* tp_compare */
59319 (reprfunc) swig_varlink_repr, /* tp_repr */
59320 0, /* tp_as_number */
59321 0, /* tp_as_sequence */
59322 0, /* tp_as_mapping */
59323 0, /* tp_hash */
59324 0, /* tp_call */
59325 (reprfunc)swig_varlink_str, /* tp_str */
59326 0, /* tp_getattro */
59327 0, /* tp_setattro */
59328 0, /* tp_as_buffer */
59329 0, /* tp_flags */
59330 varlink__doc__, /* tp_doc */
59331 0, /* tp_traverse */
59332 0, /* tp_clear */
59333 0, /* tp_richcompare */
59334 0, /* tp_weaklistoffset */
59335 #if PY_VERSION_HEX >= 0x02020000
59336 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
59337 #endif
59338 #if PY_VERSION_HEX >= 0x02030000
59339 0, /* tp_del */
59340 #endif
59341 #ifdef COUNT_ALLOCS
59342 0,0,0,0 /* tp_alloc -> tp_next */
59343 #endif
59344 };
59345 varlink_type = tmp;
59346 varlink_type.ob_type = &PyType_Type;
59347 type_init = 1;
59348 }
59349 return &varlink_type;
59350 }
59351
59352 /* Create a variable linking object for use later */
59353 SWIGINTERN PyObject *
59354 SWIG_Python_newvarlink(void) {
59355 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
59356 if (result) {
59357 result->vars = 0;
59358 }
59359 return ((PyObject*) result);
59360 }
59361
59362 SWIGINTERN void
59363 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
59364 swig_varlinkobject *v = (swig_varlinkobject *) p;
59365 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
59366 if (gv) {
59367 size_t size = strlen(name)+1;
59368 gv->name = (char *)malloc(size);
59369 if (gv->name) {
59370 strncpy(gv->name,name,size);
59371 gv->get_attr = get_attr;
59372 gv->set_attr = set_attr;
59373 gv->next = v->vars;
59374 }
59375 }
59376 v->vars = gv;
59377 }
59378
59379 SWIGINTERN PyObject *
59380 SWIG_globals() {
59381 static PyObject *_SWIG_globals = 0;
59382 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
59383 return _SWIG_globals;
59384 }
59385
59386 /* -----------------------------------------------------------------------------
59387 * constants/methods manipulation
59388 * ----------------------------------------------------------------------------- */
59389
59390 /* Install Constants */
59391 SWIGINTERN void
59392 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
59393 PyObject *obj = 0;
59394 size_t i;
59395 for (i = 0; constants[i].type; ++i) {
59396 switch(constants[i].type) {
59397 case SWIG_PY_POINTER:
59398 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
59399 break;
59400 case SWIG_PY_BINARY:
59401 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
59402 break;
59403 default:
59404 obj = 0;
59405 break;
59406 }
59407 if (obj) {
59408 PyDict_SetItemString(d, constants[i].name, obj);
59409 Py_DECREF(obj);
59410 }
59411 }
59412 }
59413
59414 /* -----------------------------------------------------------------------------*/
59415 /* Fix SwigMethods to carry the callback ptrs when needed */
59416 /* -----------------------------------------------------------------------------*/
59417
59418 SWIGINTERN void
59419 SWIG_Python_FixMethods(PyMethodDef *methods,
59420 swig_const_info *const_table,
59421 swig_type_info **types,
59422 swig_type_info **types_initial) {
59423 size_t i;
59424 for (i = 0; methods[i].ml_name; ++i) {
59425 const char *c = methods[i].ml_doc;
59426 if (c && (c = strstr(c, "swig_ptr: "))) {
59427 int j;
59428 swig_const_info *ci = 0;
59429 const char *name = c + 10;
59430 for (j = 0; const_table[j].type; ++j) {
59431 if (strncmp(const_table[j].name, name,
59432 strlen(const_table[j].name)) == 0) {
59433 ci = &(const_table[j]);
59434 break;
59435 }
59436 }
59437 if (ci) {
59438 size_t shift = (ci->ptype) - types;
59439 swig_type_info *ty = types_initial[shift];
59440 size_t ldoc = (c - methods[i].ml_doc);
59441 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
59442 char *ndoc = (char*)malloc(ldoc + lptr + 10);
59443 if (ndoc) {
59444 char *buff = ndoc;
59445 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
59446 if (ptr) {
59447 strncpy(buff, methods[i].ml_doc, ldoc);
59448 buff += ldoc;
59449 strncpy(buff, "swig_ptr: ", 10);
59450 buff += 10;
59451 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
59452 methods[i].ml_doc = ndoc;
59453 }
59454 }
59455 }
59456 }
59457 }
59458 }
59459
59460 #ifdef __cplusplus
59461 }
59462 #endif
59463
59464 /* -----------------------------------------------------------------------------*
59465 * Partial Init method
59466 * -----------------------------------------------------------------------------*/
59467
59468 #ifdef __cplusplus
59469 extern "C"
59470 #endif
59471 SWIGEXPORT void SWIG_init(void) {
59472 PyObject *m, *d;
59473
59474 /* Fix SwigMethods to carry the callback ptrs when needed */
59475 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
59476
59477 m = Py_InitModule((char *) SWIG_name, SwigMethods);
59478 d = PyModule_GetDict(m);
59479
59480 SWIG_InitializeModule(0);
59481 SWIG_InstallConstants(d,swig_const_table);
59482
59483
59484
59485 #ifndef wxPyUSE_EXPORT
59486 // Make our API structure a CObject so other modules can import it
59487 // from this module.
59488 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
59489 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
59490 Py_XDECREF(cobj);
59491 #endif
59492
59493 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
59494 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
59495 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
59496 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
59497 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
59498 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
59499 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
59500 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
59501 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
59502 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
59503 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
59504 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
59505 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
59506 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
59507 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
59508 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
59509 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
59510 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
59511 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
59512 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
59513 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
59514 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
59515 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
59516 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
59517 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
59518 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
59519 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
59520 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
59521 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
59522 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
59523 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
59524 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
59525 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
59526 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
59527 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
59528 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
59529 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
59530 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
59531 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
59532 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
59533 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
59534 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
59535 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
59536 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
59537 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
59538 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
59539 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
59540 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
59541 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
59542 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
59543 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
59544 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
59545 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
59546 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
59547 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
59548 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
59549 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
59550 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
59551 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
59552 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
59553 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
59554 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
59555 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
59556 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
59557 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
59558 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
59559 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
59560 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
59561 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
59562 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
59563 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
59564 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
59565 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
59566 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
59567 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
59568 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
59569 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
59570 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
59571 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
59572 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
59573 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
59574 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
59575 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
59576 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
59577 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
59578 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
59579 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
59580 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
59581 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
59582 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
59583 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
59584 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
59585 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
59586 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
59587 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
59588 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
59589 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
59590 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
59591 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
59592 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
59593 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
59594 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
59595 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
59596 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
59597 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
59598 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
59599 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
59600 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
59601 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
59602 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
59603 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
59604 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
59605 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
59606 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
59607 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
59608 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
59609 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
59610 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
59611 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
59612 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
59613 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
59614 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
59615 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
59616 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
59617 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
59618 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
59619 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
59620 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
59621 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
59622 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
59623 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
59624 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
59625 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
59626 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
59627 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
59628 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
59629 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
59630 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
59631 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
59632 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
59633 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
59634 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
59635 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
59636 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
59637 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
59638 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
59639 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
59640 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
59641 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
59642 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
59643 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
59644 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
59645 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
59646 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
59647 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
59648 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
59649 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
59650 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
59651 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
59652 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
59653 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
59654 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
59655 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
59656 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
59657 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
59658 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
59659 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
59660 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
59661 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
59662 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
59663 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
59664 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
59665 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
59666 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
59667 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
59668 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
59669 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
59670 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
59671 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
59672 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
59673 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
59674 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
59675 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
59676 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
59677 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
59678 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
59679 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
59680 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
59681 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
59682 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
59683 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
59684 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
59685 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
59686 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
59687 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
59688 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
59689 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
59690 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
59691 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
59692 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
59693 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
59694 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
59695 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
59696 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
59697 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
59698 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
59699 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
59700 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
59701 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
59702 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
59703 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
59704 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
59705 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
59706 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
59707 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
59708 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
59709 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
59710 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
59711 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
59712 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
59713 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
59714 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
59715 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
59716 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
59717 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
59718 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
59719 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
59720 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
59721 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
59722 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
59723 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
59724 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
59725 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
59726 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
59727 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
59728 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
59729 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
59730 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
59731 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
59732 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
59733 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
59734 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
59735 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
59736 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
59737 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
59738 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
59739 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
59740 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
59741 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
59742 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
59743 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
59744 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
59745 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
59746 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
59747 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
59748 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
59749 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
59750 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
59751 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
59752 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
59753 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
59754 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
59755 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
59756 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
59757 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
59758 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
59759 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
59760 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
59761 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
59762 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
59763 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
59764 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
59765 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
59766 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
59767 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
59768 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
59769 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
59770 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
59771 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
59772 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
59773 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
59774 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
59775 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
59776 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
59777 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
59778 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
59779 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
59780 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
59781 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
59782 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
59783 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
59784 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
59785 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
59786 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
59787 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
59788 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
59789 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
59790 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
59791 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
59792 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
59793 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
59794 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
59795 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
59796 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
59797 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
59798 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
59799 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
59800 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
59801 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
59802 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
59803 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
59804 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
59805 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
59806 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
59807 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
59808 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
59809 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
59810 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
59811 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
59812 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
59813 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
59814 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
59815 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
59816 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
59817 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
59818 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
59819 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
59820 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
59821 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
59822 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
59823 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
59824 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
59825 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
59826 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
59827 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
59828 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
59829 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
59830 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
59831 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
59832 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
59833 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
59834 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
59835 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
59836 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
59837 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
59838 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
59839 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
59840 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
59841 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
59842 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
59843 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
59844 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
59845 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
59846 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
59847 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
59848 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
59849 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
59850 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
59851 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
59852 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
59853 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
59854 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
59855 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
59856 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
59857 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
59858 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
59859 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
59860 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
59861 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
59862 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
59863 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
59864 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
59865 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
59866 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
59867 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
59868 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
59869 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
59870 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
59871 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
59872 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
59873 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
59874 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
59875 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
59876 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
59877 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
59878 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
59879 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
59880 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
59881 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
59882 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
59883 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
59884 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
59885 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
59886 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
59887 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
59888 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
59889 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
59890 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
59891 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
59892 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
59893 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
59894 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
59895 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
59896 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
59897 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
59898 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
59899 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
59900 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
59901 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
59902 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
59903 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
59904 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
59905 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
59906 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
59907 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
59908 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
59909 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
59910 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
59911 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
59912 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
59913 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
59914 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
59915 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
59916 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
59917 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
59918 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
59919 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
59920 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
59921 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
59922 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
59923 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
59924 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
59925 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
59926 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
59927 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
59928 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
59929 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
59930 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
59931 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
59932 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
59933 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
59934 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
59935 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
59936 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
59937 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
59938 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
59939 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
59940 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
59941 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
59942 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
59943 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
59944 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
59945 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
59946 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
59947 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
59948 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
59949 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
59950 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
59951 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
59952 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
59953 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
59954 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
59955 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
59956 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
59957 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
59958 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
59959 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
59960 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
59961 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
59962 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
59963 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
59964 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
59965 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
59966 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
59967 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
59968 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
59969 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
59970 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
59971 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
59972 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
59973 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
59974 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
59975 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
59976 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
59977 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
59978 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
59979 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
59980 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
59981 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
59982 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
59983 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
59984 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
59985 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
59986 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
59987 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
59988 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
59989 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
59990 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
59991 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
59992 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
59993 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
59994 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
59995 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
59996 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
59997 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
59998 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
59999 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
60000 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
60001 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
60002 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
60003 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
60004 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
60005 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
60006 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
60007 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
60008 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
60009 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
60010 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
60011 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
60012 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
60013 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
60014 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
60015 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
60016 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
60017 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
60018 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
60019 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
60020 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
60021 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
60022 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
60023 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
60024 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
60025 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
60026 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
60027 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
60028 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
60029 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
60030 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
60031 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
60032 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
60033 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
60034 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
60035 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
60036 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
60037 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
60038 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
60039 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
60040 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
60041 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
60042 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
60043 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
60044 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
60045 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
60046 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
60047 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
60048 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
60049 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
60050 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
60051 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
60052 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
60053 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
60054 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
60055 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
60056 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
60057 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
60058 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
60059 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
60060 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
60061 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
60062 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
60063 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
60064 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
60065 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
60066 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
60067 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
60068 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
60069 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
60070 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
60071 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
60072 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
60073 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
60074 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
60075 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
60076 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
60077 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
60078 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
60079 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
60080 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
60081 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
60082 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
60083 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
60084 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
60085 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
60086 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
60087 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
60088 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
60089 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
60090 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
60091 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
60092 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
60093 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
60094 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
60095 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
60096 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
60097 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
60098 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
60099 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
60100 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
60101 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
60102 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
60103 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
60104 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
60105 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
60106 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
60107 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
60108 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
60109 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
60110 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
60111 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
60112 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
60113 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
60114 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TGA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TGA)));
60115 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
60116 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
60117 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
60118 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
60119 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
60120 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
60121 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
60122 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
60123 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
60124 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
60125 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
60126 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
60127 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
60128 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
60129 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
60130 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
60131 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
60132 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
60133 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
60134 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
60135 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
60136 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
60137 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
60138 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
60139 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
60140 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
60141 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
60142 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
60143 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
60144 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
60145 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
60146 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
60147 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
60148 SWIG_Python_SetConstant(d, "Inside",SWIG_From_int(static_cast< int >(wxInside)));
60149 SWIG_Python_SetConstant(d, "OutLeft",SWIG_From_int(static_cast< int >(wxOutLeft)));
60150 SWIG_Python_SetConstant(d, "OutRight",SWIG_From_int(static_cast< int >(wxOutRight)));
60151 SWIG_Python_SetConstant(d, "OutTop",SWIG_From_int(static_cast< int >(wxOutTop)));
60152 SWIG_Python_SetConstant(d, "OutBottom",SWIG_From_int(static_cast< int >(wxOutBottom)));
60153 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
60154 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
60155 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
60156 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
60157 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
60158
60159 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
60160
60161
60162 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
60163
60164 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
60165 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
60166 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
60167 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
60168 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
60169 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
60170 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
60171 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
60172 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
60173 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
60174 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
60175 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
60176 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
60177 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
60178 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
60179 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
60180 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
60181 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
60182 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
60183 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
60184 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
60185 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
60186 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
60187 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
60188 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
60189 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
60190 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
60191 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
60192 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
60193 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
60194 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
60195 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
60196 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
60197 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
60198 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
60199 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
60200 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
60201 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
60202 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
60203 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
60204 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
60205 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
60206 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
60207 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
60208 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
60209 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
60210 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
60211 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
60212 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
60213 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
60214 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
60215 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
60216 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
60217 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
60218 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
60219 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
60220 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
60221 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
60222 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
60223 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
60224 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
60225 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
60226 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
60227 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
60228 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
60229 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
60230 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
60231 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
60232 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
60233 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
60234 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
60235 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
60236 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
60237 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
60238 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
60239 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
60240 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
60241 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
60242 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
60243 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
60244 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
60245 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
60246 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
60247 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
60248 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
60249 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
60250 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
60251 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
60252 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
60253 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
60254 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
60255 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
60256 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
60257 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
60258 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
60259 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
60260 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
60261 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
60262 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
60263 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
60264 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
60265 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
60266 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
60267 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
60268 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
60269 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
60270 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
60271 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
60272 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
60273 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
60274 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
60275 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
60276 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
60277 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
60278 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
60279 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
60280 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
60281 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
60282 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
60283 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
60284 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
60285 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
60286 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
60287 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
60288 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
60289 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
60290 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
60291 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
60292 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
60293 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
60294 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
60295 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
60296 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
60297 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
60298 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
60299 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
60300 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
60301 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
60302 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
60303 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
60304 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
60305 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
60306 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
60307 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
60308 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
60309 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
60310 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
60311 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
60312 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
60313 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
60314 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
60315 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
60316 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
60317 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
60318 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
60319 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
60320 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
60321 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
60322 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
60323 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
60324 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
60325 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
60326 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
60327 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
60328 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
60329 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
60330 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
60331 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
60332 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
60333 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
60334 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
60335 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
60336 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
60337 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
60338 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
60339 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
60340 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
60341 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
60342 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
60343 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
60344 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
60345 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
60346 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
60347 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
60348 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
60349 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
60350 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
60351 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
60352 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
60353 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
60354 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
60355 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
60356 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
60357 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
60358 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
60359 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
60360 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
60361 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
60362 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
60363 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
60364 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
60365 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
60366 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
60367 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
60368 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
60369 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
60370 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
60371 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
60372 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
60373 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
60374 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
60375 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
60376 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
60377 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
60378
60379 // Initialize threading, some globals and such
60380 __wxPyPreStart(d);
60381
60382
60383 // Although these are defined in __version__ they need to be here too so
60384 // that an assert can be done to ensure that the wxPython and the wxWindows
60385 // versions match.
60386 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
60387 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
60388 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
60389
60390 }
60391
wxWidgets (Impactor)